高速缓存对程序性能的影响

最新推荐文章于 2024-06-04 21:45:19 发布
最新推荐文章于 2024-06-04 21:45:19 发布
阅读量3.3k 收藏 3
点赞数
分类专栏： C／C++ 文章标签： 缓存 cache 局部性 存储器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TomMMRunNEr/article/details/78882319
版权

高速缓存对程序性能的影响

前言

本篇博客以“SSD6-Exercise5：Cache Lab”为例，首先介绍存储器的层次结构，重点阐述了提高程序局部性的重要性，以及编写高速缓存友好代码的方法。

存储器层次结构

如果你了解系统是如何将数据再存储器层次结构中上上下下移动的，那么你就可以编写自己的应用程序，使得它们的数据项存储在层次结构中较高的地方，在那里CPU可以更快地访问到它们。

实际上，存储器系统 (memory system) 是一个具有不同容量、成本和访问时间的存储设备的层次结构。

CPU寄存器保存着最常用的数据，靠近CPU的小的、快速的高速缓存存储器 (cache memory) 作为一部分存储在相对慢速的主存储器 (main memory) 中数据和指令的缓冲区域。主存缓存存储在容量较大的、慢速磁盘上的数据，而这些磁盘常常又作为存储在通过网络连接的其他机器的磁盘或磁带上的数据的缓冲区域。

1

如上图所示，L1、L2、L3均为不同级别的高速缓存，本篇博客主要讨论的即为高速缓存（cache）对程序性能的影响。

局部性

这些思想围绕着计算机程序的一个称为局部性 (locality) 的基本属性。具有良好局部性的程序倾向于一次又一次地访问相同的数据项集合，或者倾向于访问邻近的数据项集合。

局部性通常有两种不同的形式：时间局部性 (temporal locality) 和空间局部性 (spatial locality) 。

  • 时间局部性：被引用过一次的内存位置，很可能在不远的将来再被多次引用。
  • 空间局部性：如果一个内存位置被引用了一次，那么程序很可能在不远的将来饮用附近的一个内存位置。

在量化评价程序中的局部性时，还有以下的一些原则：

  • 重复引用相同变量的程序，具有良好的时间局部性。
  • 对于具有步长为k的引用模式的程序，步长越小，空间局部性越好。
  • 对于取指令来说，循环有好的时间和空间局部性。循环体越小，循环迭代次数越多，局部性越好。
性能影响

局部性好的程序更容易有较低的不命中率，而不命中率较低的程序往往比不命中率较高的程序运行得更快。

因此，从具有良好局部性的意义上来说，好的程序员总是应该试着去编写高速缓存友好 (cache friendly) 的代码。

下面是我们用来确保代码高速缓存友好的基本方法：

  1. 让最常见的情况运行得快.
  2. 尽量减少每个循环内部的缓存不命中数量.

实例：编写高速缓存友好的代码

题目要求

题目详情参见“SSD6-Exercise5：Cache Lab”。下面将题目中的几个重点特别说明：

  • Cache Structure: 16KB directed-mapped cahe, with 32-byte cache lines
  • Assumptions: To make optimization easier, you may assume that the image dimensions will always be a multiple of 32.
  • Hints:
    • The rotate function focuses on spatial locality: because each pixel is used only once,you should focus on using any pixels put into the cache by a previous pixel operation.
    • The smooth function benefits from spatial locality, but also reuses pixels it has readpreviously. Consequently, you should consider trying to improve temporal locality as well.

Naive Functions

未经局部性优化时，smooth()与rotate()函数的实现分别如下：

Smooth
void smooth(int dim, pixel *src, pixel *dst) {
    int i, j;
    for(i=0; i<dim;i++) {
        COPY(&dst[PIXEL(i,0,dim)], &src[PIXEL(i,0,dim)]);
        COPY(&dst[PIXEL(i,dim-1,dim)], &src[PIXEL(i,dim-1,dim)]);
    }
    for(j=1; j<dim-1;j++) {
        COPY(&dst[PIXEL(0,j,dim)], &src[PIXEL(0,j,dim)]);
        COPY(&dst[PIXEL(dim-1,j,dim)], &src[PIXEL(dim-1,j,dim)]);
    }
    for(i=1; i<dim-1; i++) {
        for(j=1; j<dim-1; j++) {
            SMOOTH(&dst[PIXEL(j,i,dim)],
                    &src[PIXEL(j,i,dim)],
                    &src[PIXEL(j-1,i,dim)],
                    &src[PIXEL(j+1,i,dim)],
                    &src[PIXEL(j,i+1,dim)],
                    &src[PIXEL(j,i-1,dim)],
                    &src[PIXEL(j-1,i-1,dim)],
                    &src[PIXEL(j+1,i+1,dim)],
                    &src[PIXEL(j-1,i+1,dim)],
                    &src[PIXEL(j+1,i-1,dim)]);
        }
    }
    return;
}

smooth()分别对像素点(j, i)及其周围的8个点进行复制。

Rotate
void rotate(int dim, pixel *src, pixel *dst) {
    int i, j;

    for(i=0; i < dim; i++) {
        for(j=0; j < dim; j++) {
            COPY(&dst[PIXEL(dim-1-j,i,dim)], &src[PIXEL(i,j,dim)]);
        }
    }

    return;
}

rotate()将像素点(i, j)复制到(dim-1-j, i)处。

设计思路

根据上文对局部性的介绍，再根据题目中所提供的线索，我们可以从以下的角度设计对高速缓存友好的代码：

  • Smooth：利用空间局部性，避免读取数组元素时多次跳跃。
  • Rotate：对于源像素集合的遍历，与目标像素集合的遍历，不可能在步长为1的情况下，同时追求二者均达到较好的局部性。因此，可采用矩阵分块的方法，改变步长与循环层数。

具体实现

Smooth
void smooth(int dim, pixel *src, pixel *dst) {
    int i, j;
    for (i = 0; i < dim; i++) {
        COPY(&dst[PIXEL(i, 0, dim)], &src[PIXEL(i, 0, dim)]);
        COPY(&dst[PIXEL(i, dim - 1, dim)], &src[PIXEL(i, dim - 1, dim)]);
    }
    for (j = 1; j < dim - 1; j++) {
        COPY(&dst[PIXEL(0, j, dim)], &src[PIXEL(0, j, dim)]);
        COPY(&dst[PIXEL(dim - 1, j, dim)], &src[PIXEL(dim - 1, j, dim)]);
    }
    for (j = 1; j < dim - 1; j++) {
        for (i = 1; i < dim - 1; i++) {
            SMOOTH(
                   &dst[PIXEL(j, i, dim)],
                   &src[PIXEL(j, i - 1, dim)],
                   &src[PIXEL(j, i, dim)],
                   &src[PIXEL(j, i + 1, dim)],
                   &src[PIXEL(j - 1, i, dim)],
                   &src[PIXEL(j + 1, i, dim)],
                   &src[PIXEL(j - 1, i - 1, dim)],
                   &src[PIXEL(j + 1, i + 1, dim)],
                   &src[PIXEL(j - 1, i + 1, dim)],
                   &src[PIXEL(j + 1, i - 1, dim)]
                   );
        }
    }
    return;
}

上述代码改变了i与j的层顺序，从而实现了较好的空间局部性与时间局部性。

Rotate
void rotate(int dim, pixel *src, pixel *dst) {
    int mat = 4;

    for(int col = 0; col < dim; col += mat)
        for (int row = 0; row < dim; row += mat)
            for (int j = col + mat - 1;j >= col;j-- )
                for (int i = row; i < row + mat; i++)
                    COPY(&dst[PIXEL(dim - 1 - j, i, dim)], &src[PIXEL(i, j, dim)]);
}

根据“Cache Structure: 16KB directed-mapped cahe, with 32-byte cache lines”的高速缓存结构，在这里采取步长为4的策略，并加深循环的层数以达到良好的空间局部性。

测试结果

测试结果如下：

DEBUG: dimension=64.0
DEBUG: work=4096.0
DEBUG: dimension=128.0
DEBUG: work=16384.0
DEBUG: dimension=256.0
DEBUG: work=65536.0
DEBUG: dimension=512.0
DEBUG: work=262144.0
DEBUG: dimension=1024.0
DEBUG: work=1048576.0
Rotate: Version = Rotate Reference Naive Implementation!:
Dim 64  128 256 512 1024    Mean
hitrate 86.8    43.8    43.8    43.7    43.7
Incr.   1.00    1.00    1.00    1.00    1.00    1.00

DEBUG: dimension=64.0
DEBUG: work=4096.0
DEBUG: dimension=128.0
DEBUG: work=16384.0
DEBUG: dimension=256.0
DEBUG: work=65536.0
DEBUG: dimension=512.0
DEBUG: work=262144.0
DEBUG: dimension=1024.0
DEBUG: work=1048576.0
Rotate: Version = Exchanged-Matrix Row-wise Traversal of src:
Dim 64  128 256 512 1024    Mean
hitrate 87.1    81.2    81.2    80.9    81.0
Incr.   1.00    1.86    1.86    1.85    1.85    1.64

Best algo here: Exchanged-Matrix Row-wise Traversal of src,     1.640945


DEBUG: dimension=64.0
DEBUG: work=4096.0
DEBUG: dimension=128.0
DEBUG: work=16384.0
DEBUG: dimension=256.0
DEBUG: work=65536.0
DEBUG: dimension=512.0
DEBUG: work=262144.0
DEBUG: dimension=1024.0
DEBUG: work=1048576.0
Smooth: Version = Smooth Reference Naive Implementation!:
Dim 64  128 256 512 1024    Mean
hitrate 63.1    45.4    45.6    45.7    45.8
Incr.   1.00    1.00    1.00    1.00    1.00    1.00

DEBUG: dimension=64.0
DEBUG: work=4096.0
DEBUG: dimension=128.0
DEBUG: work=16384.0
DEBUG: dimension=256.0
DEBUG: work=65536.0
DEBUG: dimension=512.0
DEBUG: work=262144.0
DEBUG: dimension=1024.0
DEBUG: work=1048576.0
Smooth: Version = Exchanged-row-column Traversal of src:
Dim 64  128 256 512 1024    Mean
hitrate 63.1    63.8    64.2    64.4    64.5
Incr.   1.00    1.41    1.41    1.41    1.41    1.31

Best algo here: Exchanged-row-column Traversal of src,  1.314475

Program ended with exit code: 0

我们可以看到每个函数在处理各尺寸图像时cache的命中率，通过局部性的改良，程序的运行速度得到了极大的提升。

总结

高速缓存友好的代码特点

  1. 让最常见的情况运行得快。程序通常把大部分时间都花在少量的核心函数上，而这些函数通常把大部分时间都花在了少量的循环上。所以要把注意力集中在核心函数的循环上，而忽略其他部分。

  2. 在每个循环内部使缓存不命中数量最小。在其他条件，例如加载和存储的总次数相同的情况下，不命中率低的程序运行得更快。

    注意：编译器将局部变量存储到寄存器中，因此循环内对局部变量的引用不需要任何加载或存储指令。

    高速缓存对程序性能的影响

  3. 通过重新排列循环以提高空间局部性：降低高速缓冲的不命中率。例子（求两个矩阵的乘积）

  4. 使用分块来提高时间局部性。

分块的大致思想是将一个程序中的数据结构组织成称为块（block）的组块（chunk）。这里的“块”指的是一个应用级的块，不是高速缓冲块。这样构造程序，使得能够将一个块加载到L1高速缓存中，并在这个块中进行所需的所有的读和写，然后丢掉这个块，加载下一个块，以此类推。

参考资料

[1] 《深入理解计算机系统》（第3版）.Randal E. Bryant, David R.O’Hallaron 著.

[2] 博客：程序设计原则——局部性原理.

[3] 博客：SSD6-Exercise5：Cache Lab

RMSnow
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
磁盘高速缓存程序
11-26
总结来说，磁盘高速缓存程序是提升计算机性能的关键工具，SMARTDRV.EXE是DOS时代的一个典型代表。通过有效地管理和使用内存，它可以显著提高文件复制和其他磁盘操作的速度。在使用前，用户应确保正确配置和理解相关...
25 | 容量场景之二：缓存对性能会有什么样的影响？
qq_37756660的博客
04-01 1104
从基准场景做完之后，我们来到了容量场景，这是一个非常大的变化。在这个场景中，我们解决了几个问题并最终给出了结论：第一个阶段：分析了压力工具参数化的问题，解决了 TPS 不断降低、响应时间不断上升的问题。第二个阶段：分析了数据库索引，解决了 TPS 低的问题。第三个阶段：分析了资源争用，解决了多容器跑到一个节点上的问题。第四个阶段：分析了网络争用和 Redis 的 AOF，解决了 TPS 不稳定的问题。第五个阶段：递增压力，给出最终系统整体容量的结论。
Cache 结构对程序性能的影响
LSEC小陆的博客
03-03 1128
Cache结构对程序性能的影响一个例子，我们来看看矩阵乘法中不同循环顺序对程序性能的影响： 写一个c代码，很简单 #include <stdio.h> #include <stdlib.h> #define m 1000float a[m][m]; float b[m][m]; float c[m][m]; main() { int i,j,k,i0,j0; srand((unsign
计算机系统基础笔记（9）——高速缓存
最新发布
Annaaaaa1的博客
06-04 564
◼ 2次内存加载，0次存储◼ 未命中次数/循环 = 1.25◼ 2次内存加载，1次存储◼ 未命中次数/循环 = 0.5◼ 2次内存加载，1次存储◼ 未命中次数/循环 = 2.0存储器山了解概念即可高速缓存的结构这部分 要知道三种不同的高速缓存类型 以及 高速缓存的性能指标。
评估cache中的数据预期技术
zhangqiagn1104的专栏
11-12 966
1.设计数据密集型程序，评估CPU数据预取效果： 建立一个长度为1024*1024*64的一维数组，不采用预取技术的方法是，以16为步长（尽量保持数据不在一个cache行）取数据，并作运算，计算该过程所用时间；采用预取技术的方法是，采用_mm_prefetch函数进行数组的欲取，仍然以16为步长（尽量保持数据不再一个cache行）取数据，并作运算，计算该过程所用时间。源代码如下，在win7命令行
深入了解计算机系统--高速缓存的理解
m0_64396392的博客
08-22 543
记录学习计算机系统缓存部分和高速缓存寻址的过程理解
二、Cache_上
凡物加倍磨治，皆能变化气质
07-10 7947
ARM学习书籍或者思路总结，以XMIND 为形式，构建思维大厦，蛰伏与积累，下面补充对XMIND的描述 本篇参考 arm 官网公开材料，和微信公众号 老秦谈芯 学习笔记 1.什么是cache Cache存储器也被称为高速缓冲存储器，位于CPU和主存储器之间。之所以在CPU和主存之间要加cache是因为现代的CPU频率大大提高，内存的发展已经跟不上CPU访存的速度。在2001 – 2005年间，处理器时钟频率以每年55%的速度增长，而主存的增长速度只是7%。在现在的系统中，处理器需要上百个时钟周期才能从主.
通用高速缓存原理
zhong_ethan的博客
10-15 1417
扒一扒高速缓存（cache）的原理
SQL Server 高速缓存依赖分析
09-11
SQL Server 高速缓存依赖分析是指使用 SQL Server 高速缓存依赖性的步骤，以提高数据库的性能和可扩展性。高速缓存依赖性是指在ASP.NET应用程序中使用SQL Server高速缓存来实现缓存依赖性，提高应用程序的响应速度和...
09配置+servlet+高速缓存
01-25
因为 Java Server Pages 文件被编译成 servlet，所以动态高速缓存功能对 Java Server Pages 文件的处理与对 servlet 的处理是一样的（特别说明的情况除外）。 过程 在管理控制台中，单击控制台导航树中的服务器 > ...
如何编写高性能的应用程序
02-04
在这个硬件性能日新月异的年代里，我们充分的享受着硬件带给我们的“免费午餐”，似忽软件的效率问题已经不再是一种被开发者关心的问题，但是，随着CPU的主频提高步伐越来越慢，高速缓存也不是可以无限制增加，新...
cache-friendly:Java的缓存友好算法和数据结构
04-29
缓存友好 Java的缓存友好算法和数据结构 偏二元搜寻 org.reific.binarysearch.biased.BiasedBinarySearch.binarySearch是Arrays.binarySearch的直接替代，它对于大尺寸2的幂的数组不会受到缓存行混叠的影响。 org.reific.binarysearch.biased.evolve.EvolveBinarySearchConstant （位于tst目录中）运行一种遗传算法来演化BiasedBinarySearch中使用的常数。
高速缓存实现源码
10-21
高速缓存是计算机科学中的一个重要概念，特别是在优化应用程序性能方面起着关键作用。在Java编程环境中，高速缓存的实现可以极大地提升系统响应速度，尤其是在处理高并发场景时。本项目通过源码实现了一个简单的高速...
CPU 缓存如何影响你的 Go 程序性能
光谷码农
10-11 333
小菜刀最近在medium上阅读了一篇高赞文章《Go and CPU Caches》，其地址为https://teivah.medium.com/go-and-cpu-caches-af5d...
关于为什么使用缓存能提高程序执行效率
Zhangsama1的博客
03-18 1623
先来解释一下上面这张图片,从图中可以看出首先主存与CPU之间的存取速度的差异非常大,而主存中存放的,是每个程序运行时所需要的数据,CPU需要从主存中存取这些数据,但是由于主存与CPU存取速度的差异,导致了限制程序运行效率的因素并非CPU的速度不够快,而是由于存储设备准备数据较慢导致的,因此为了充分发挥CPU的行能,现代存储体系选择在CPU与主存之间增加一个高速缓存(Cache),高速缓存与CPU才用同一种材料制成,因此CPU与缓存之间的访问几乎没有时延(所以缓存的容量非常小,因为非常贵).如下所示是我电脑.
系统缓存全解析（四）——应用程序数据缓存和文件缓存依赖
O Wen
09-15 970
<br />1.  应用程序数据缓存<br />System.Web.Caching 命名空间提供用于缓存服务器上常用数据的类。此命名空间包括 Cache 类，该类是一个字典，您可以在其中存储任意数据对象，如哈希表和数据集。它还为这些对象提供了失效功能，并为您提供了添加和移除这些对象的方法。您还可以添加依赖于其他文件或缓存项的对象，并在从 Cache 对象中移除对象时执行回调以通知应用程序。<br />/// <summary><br />/// 获取当前应用程序指定CacheKey的Cache对象值<br
性能：操作系统是如何影响应用程序执行时间的
OceanStar的博客
12-24 441
行锁 在多个事务并发更新数据的时候，都是要在行级别加独占锁的，这就是行锁。 独占锁都是互斥的，所以不可能发生脏写问题，一个事务提交了才会释放自己的独占锁，唤醒下一个事务执行。 如果数据更新的时候，别的事务去读取这行数据，有两种可能： 第一种可能是基于MVCC机制进行事务隔离，读取快照版本，这是比较常见的 第二种可能是查询的同时基于特殊语法去加独占锁或者共享锁 如果你查询的时候加独占锁，那么跟其他更新数据的事务加的独占锁都是互斥的； 如果你查询的时候加共享锁，那么跟其他查询加的共享锁不是互斥的，但是跟
【深入理解计算机系统】CSAPP-实验五：CacheLab(未完成）
qq_42234461的博客
09-25 2067
前言 本章帮助理解告诉缓存对程序性能的影响。包含两个部分： 第一部分是写两三百行代码来模拟高速缓存。 第二部分是优化矩阵转置计算，使得cache miss次数最少。 本机使用win10 +wsl2.0 + ubuntu18.04完成实验。 点击查看我的全部代码 倒是CMU的官网打开了。两天了。 从github上下载了实验数据。 reference CSAPP-Labs-实验材料-含有PDF CSAPP-Labs-实验材料-含有源文件 深入理解计算机系统-cachelab CSAPP-cachelab 解题思
缓存命中和性能的关系论证
weixin_30911809的博客
11-19 199
《性能之巅》中关于性能和缓存部分，有两点在读到是有一些困惑，做以下思考。 1. 为什么99%的缓存命中，和98%的缓存命中，两者性能差距，远大于11%和10%的差距 具体的论证仔细思考了一下，可以推导如下： 现做以下变量定义： k：命中率，[0，1]之间 t：没有命中的处理耗时，[1，max]，此处假设命中后的处理时间是1，此处假定命中和不命中的处理速度为固定倍数差异。 A：总的任务量...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值