摘要：CPU内置大量的高速缓存的重要性显而易见，在体积、老本、效率等因素下产生了当今用到的计算机的存储构造。
1. 介 绍
2. CPU缓存的构造
3. 缓存的存取与统一
4. 代码设计的考量
5. 最 后
CPU频率太快，其处理速度远快于存储介质的读写。因而，导致CPU资源的节约，须要无效解决IO速度和CPU运算速度之间的不匹配问题。芯片级高速缓存可大大减少之间的解决提早。CPU制作工艺的提高使得在比以前更小的空间中装置数十亿个晶体管，如此可为缓存留出更多空间，使其尽可能地凑近外围。
CPU内置大量的高速缓存的重要性显而易见，在体积、老本、效率等因素下产生了当今用到的计算机的存储构造。
- 介 绍
计算机的内存具备基于速度的层次结构，CPU高速缓存位于该层次结构的顶部，是介于CPU内核和物理内存(动态内存DRAM)之间的若干块动态内存，是最快的。它也是最靠近中央处理的中央，是CPU自身的一部分，个别间接跟CPU芯片集成。
CPU计算：程序被设计为一组指令，最终由CPU运行。
装载程序和数据，先从最近的一级缓存读取，如有就间接返回，逐层读取，直至从内存及其它内部存储中加载，并将加载的数据顺次放入缓存。
高速缓存中的数据写回主存并非立刻执行，写回主存的机会：
1.缓存满了，采纳先进先出或最久未应用的程序写回；
2.#Lock信号，缓存一致性协定，明确要求数据计算实现后要立马同步回主存。
- CPU缓存的构造
古代的CPU缓存构造被分为多解决、多核、多级的档次。
2.1 多级缓存构造
分为三个次要级别，即L1，L2和L3。离CPU越近的缓存，读取效率越高，存储容量越小，造价越高。
L1高速缓存是零碎中存在的最快的内存。就优先级而言，L1缓存具备CPU在实现特定工作时最可能须要的数据，大小通常可达256KB，一些功能强大的CPU占用近1MB。某些服务器芯片组(如Intel高端Xeon CPU)具备1-2MB。L1缓存通常又分为指令缓存和数据缓存。指令缓存解决无关CPU必须执行的操作的信息，数据缓存则保留要在其上执行操作的数据。如此，缩小了争用Cache所造成的抵触，进步了处理器效力。
L2级缓存比L1慢，但大小更大，通常在256KB到8MB之间，功能强大的CPU往往会超过此大小。L2高速缓存保留下一步可能由CPU拜访的数据。大多数CPU中，L1和L2高速缓存位于CPU内核自身，每个内核都有本人的高速缓存。
L3级高速缓存是最大的高速存储单元，也是最慢的。大小从4MB到50MB以上。古代CPU在CPU裸片上具备用于L3高速缓存的专用空间，且占用了很大一部分空间。
2.2 多处理器缓存构造
计算机早已进入多核时代，软件也运行在多核环境。一个处理器对应一个物理插槽、蕴含多个核（一个核蕴含寄存器、L1 Cache、L2 Cache），多核间共享L3 Cache，多处理器间通过QPI总线相连。
L1 和 L2 缓存为CPU单个外围公有的缓存，L3 缓存是同插槽的所有外围都共享的缓存。
L1缓存被分成独立的32K数据缓存和32K指令缓存，L2缓存被设计为L1与共享的L3缓存之间的缓冲。大小为256K，次要作为L1和L3之间的高效内存拜访队列,同时蕴含数据和指令。L3缓存包含了在同一个槽上的所有L1和L2缓存中的数据。这种设计耗费了空间，但可拦挡对L1和L2缓存的申请，加重了各个外围公有的L1和L2缓存的累赘。
2.3 Cache Line
Cache存储数据以固定大小为单位，称为Cache Line/Block。给定容量和Cache Line size，则就固定了存储的条目个数。对于X86，Cache Line大小与DDR一次访存能失去的数据大小统一，即64B。旧的ARM架构的Cache Line是32B，因而常常是一次填两个Cache Line。CPU从Cache获取数据的最小单位为字节，Cache从Memory获取的最小单位是Cache Line，Memory从磁盘获取数据通常最小是4K。
Cache分成多个组，每组分成多个Cache Line行，大抵如下图：
Linux零碎下应用以下命令查看Cache信息，lscpu命令也可。
- 缓存的存取与统一
上面表格形容了不同存储介质的存取信息，供参考。
存取速度：寄存器 > cache(L1~L3) > RAM > Flash > 硬盘 > 网络存储
以2.2Ghz频率的CPU为例，每个时钟周期大略是0.5纳秒。
3.1 读取存储器数据
按CPU层级缓存构造，取数据的程序是先缓存再主存。当然，如数据来自寄存器，只需间接读取返回即可。
1) 如CPU要读的数据在L1 cache，锁住cache行，读取后解锁、返回
2) 如CPU要读的数据在L2 cache，数据在L2里加锁，将数据复制到L1，再执行读L1
3) 如CPU要读的数据在L3 cache，也一样，只不过先由L3复制到L2，再从L2复制到L1，最初从L1到CPU
4) 如CPU需读取内存，则首先告诉内存控制器占用总线带宽，后内存加锁、发动读申请、期待回应，回应数据保留至L3，L2,L1，再从L1到CPU后解除总线锁定。
3.2 缓存命中与提早
因为数据的局部性原理，CPU往往须要在短时间内反复屡次读取数据，内存的运行频率远跟不上CPU的处理速度，缓存的重要性被凸显。CPU可避开内存在缓存里读取到想要的数据，称之为命中。L1的运行速度很快，但容量很小，在L1里命中的概率大略在80%左右，L2、L3的机制也相似。这样一来，CPU须要在主存中读取的数据大略为5%-10%，其余命中全副能够在L1、L2、L3中获取，大大减少了零碎的响应工夫。
高速缓存旨在放慢主内存和CPU之间的数据传输。从内存拜访数据所需的工夫称为提早，L1具备最低提早且最靠近外围，而L3具备最高的提早。缓存未命中时，因为CPU需从主存储器中获取数据，导致提早会更多。
3.3 缓存替换策略
Cache里的数据是Memory中罕用数据的一个拷贝，存满后再存入一个新的条目时，就须要把一个旧的条目从缓存中拿掉，这个过程称为evict。缓存治理单元通过肯定的算法决定哪些数据须要从Cache里移出去，称为替换策略。最简略的策略为LRU，在CPU设计的过程中，通常会对替换策略进行改良，每一款芯片简直都应用了不同的替换策略。
3.4 MESI缓存一致性
在多CPU的零碎中，每个CPU都有本人的本地Cache。因而，同一个地址的数据，有可能在多个CPU的本地 Cache 里存在多份拷贝。为了保障程序执行的正确性，就必须保障同一个变量，每个CPU看到的值都是一样的。也就是说，必须要保障每个CPU的本地Cache中可能如实反映内存中的实在数据。
假如一个变量在CPU0和CPU1的本地Cache中都有一份拷贝，当CPU0批改了这个变量时，就必须以某种形式告诉CPU1，以便CPU1可能及时更新本人本地Cache中的拷贝，这样能力在两个CPU之间保持数据的同步，CPU之间的这种同步有较大开销。
为保障缓存统一，古代CPU实现了非常复杂的多核、多级缓存一致性协定MESI, MESI具体的操作上会针对单个缓存行进行加锁。
MESI：Modified Exclusive Shared or Invalid
1) 协定中的状态
CPU中每个缓存行应用4种状态进行标记(应用额定的两位bit示意)
M: Modified
该缓存行只被缓存在该CPU的缓存中，且被批改过(dirty),即与主存中的数据不统一，该缓存行中的内容需在将来的某个工夫点(容许其它CPU读取主存中相应内存之前)写回主存。当被写回主存之后，该缓存行的状态变成独享(exclusive)状态
E: Exclusive
该缓存行只被缓存在该CPU的缓存中，未被批改，与主存中数据统一。在任何时刻当有其它CPU读取该内存时变成shared状态。同样，当批改该缓存行中内容时，该状态能够变成Modified状态.
S: Shared
象征该缓存行可能被多个CPU缓存，各个缓存中的数据与主存数据统一，当有一个CPU批改该缓存行中，其它CPU中该缓存行能够被作废(Invalid).
I: Invalid，缓存有效(可能其它CPU批改了该缓存行)
2) 状态切换关系
由下图可看出cache是如何保障它的数据一致性的。
譬如，以后外围要读取的数据块在其外围的cache状态为Invalid，在其余外围上存在且状态为Modified的状况。能够从以后外围和其它外围两个角度观察，其它外围角度：以后状态为Modified，其它外围想读这个数据块(图中Modified到Shared的绿色虚线)：先把扭转后的数据写入到内存中(先于其它外围的读)，并更新该cache状态为Share.以后外围角度：以后状态为Invalid，想读这个数据块(图中Invalid到Shared的绿色实线)：这种状况下会从内存中从新加载，并更新该cache状态Share
以下表格从这两个角度列举了所有状况，供参考：
3) 缓存的操作形容
一个典型零碎中会有几个缓存(每个外围都有)共享主存总线，每个相应的CPU会收回读写申请，而缓存的目标是为了缩小CPU读写共享主存的次数。
l 一个缓存除在Invalid状态外都能够满足CPU的读申请，一个Invalid的缓存行必须从主存中读取(变成S或 E状态)来满足该CPU的读申请。
l 一个写申请只有在该缓存行是M或E状态时能力被执行，如果缓存行处于S状态，必须先将其它缓存中该缓存行变成Invalid(不容许不同CPU同时批改同一缓存行，即便批改该缓存行中不同地位的数据也不可)，该操作常以播送形式来实现。
l 缓存能够随时将一个非M状态的缓存行作废，或变成Invalid，而一个M状态的缓存行必须先被写回主存。一个处于M状态的缓存行必须时刻监听所有试图读该缓存行绝对主存的操作，操作必须在缓存将该缓存行写回主存并将状态变成S状态之前被提早执行。
l 一个处于S状态的缓存行需监听其它缓存使该缓存行有效或独享该缓存行的申请，并将该缓存行变成有效。
l 一个处于E状态的缓存行也必须监听其它读主存中该缓存行的操作，一旦有这种操作，该缓存行需变成S状态。
l 对于M和E状态而言总是准确的，和该缓存行的真正状态是统一的。而S状态可能是非统一的，如果一个缓存将处于S状态的缓存行作废了，而另一个缓存实际上可能曾经独享了该缓存行，然而该缓存却不会将该缓存行升迁为E状态，是因为其它缓存不会播送作废掉该缓存行的告诉，同样，因为缓存并没有保留该缓存行的copy的数量，因而也没有方法确定本人是否曾经独享了该缓存行。
从下面的意义来看，E状态是一种投机性的优化：如果一个CPU想批改一个处于S状态的缓存行，总线事务须要将所有该缓存行的copy变成Invalid状态，而批改E状态的缓存不须要应用总线事务。
- 代码设计的考量
了解计算机存储器层次结构对应用程序的性能影响。如果须要的程序在CPU寄存器中，指令执行时1个周期内就能拜访到；如果在CPU Cache中，需1~30个周期；如果在主存中，须要50~200个周期；在磁盘上，大略须要万级周期。另外，Cache Line的存取也是代码设计者须要关注的局部, 以躲避伪共享的执行场景。因而，充分利用缓存的构造和机制可无效进步程序的执行性能。
4.1 局部性个性
一旦CPU要从内存或磁盘中拜访数据就会产生一个很大的时延，程序性能显著升高，为此咱们不得不进步Cache命中率，也就是充分发挥局部性原理。一般来说，具备良好局部性的程序会比局部性较差的程序运行得更快，程序性能更好。
局部性机制确保在拜访存储设备时，存取数据或指令都趋于汇集在一片间断的区域。一个设计低劣的计算机程序通常具备很好的局部性，工夫局部性和空间局部性。
1) 工夫局部性
如果一个数据/信息项被拜访过一次，那么很有可能它会在很短的工夫内再次被拜访。比方循环、递归、办法的重复调用等。
2) 空间局部性
一个Cache Line有64字节块，能够充分利用一次加载64字节的空间，把程序后续会拜访的数据，一次性全副加载进来，从而进步Cache Line命中率（而非从新去寻址读取）。如果一个数据被拜访，那么很有可能位于这个数据左近的其它数据也会很快被拜访到。比方程序执行的代码、间断创立的多个对象、数组等。数组就是一种把局部性原理利用到极致的数据结构。
3) 代码示例
示例1，(C语言)
//程序 array1.c 多维数组替换行列拜访程序char array[10240][10240];int main(int argc, char *argv[]){ int i = 0; int j = 0; for(i=0; i < 10240 ; i++) { for(j=0; j < 10240 ; j++) { array[i][j] = ‘A’; //按行进行拜访 } } return 0;}红色字体的代码调整为： arrayj = ‘A’; //按列进行拜访
编译、运行后果如下：
从测试后果看，第一个程序运行耗时0.265秒，第二个1.998秒，是第一个程序的7.5倍。
案例参考：https://www.cnblogs.com/wangh...
后果剖析
数组元素存储在地址间断的内存中，多维数组在内存中是按行进行存储。第一个程序按行拜访某个元素时，该元素左近的一个Cache Line大小的元素都会被加载到Cache中，这样一来，在拜访紧挨着的下一个元素时，就可间接拜访Cache中的数据，不需再从内存中加载。也就是说，对数组按行进行拜访时，具备更好的空间局部性，Cache命中率更高。
第二个程序按列拜访某个元素，尽管该元素左近的一个Cache Line大小的元素也会被加载进Cache中，但接下来要拜访的数据却不是紧挨着的那个元素，因而很有可能会再次产生Cache miss，而不得不从内存中加载数据。而且，尽管Cache中会尽量保留最近拜访过的数据，但Cache大小无限，当Cache被占满时，就不得不把一些数据给替换掉。这也是空间局部性差的程序更容易产生Cache miss的重要起因之一。
示例2，（Java）
以下代码中长度为16的row和column数组，在Cache Line 64字节数据块上内存地址是间断的，能被一次加载到Cache Line中，在拜访数组时命中率高，性能施展到极致。
public int run(int[] row, int[] column) { int sum = 0; for(int i = 0; i < 16;i++ ) { sum += row[i] * column[i]; } return sum;}变量i体现了工夫局部性，作为计数器被频繁操作，始终寄存在寄存器中，每次从寄存器拜访，而不是从缓存或主存拜访。
4.2 缓存行的锁竞争
在多处理器下，为保障各个处理器的缓存统一，会实现缓存一致性协定，每个处理器通过嗅探在总线上流传的数据来查看本人缓存的值是不是过期，当处理器发现自己缓存行对应的内存地址被批改，就会将以后处理器的缓存行置成有效状态，当处理器要对这个数据进行批改操作的时候，会强制从新从零碎内存里把数据读到处理器缓存里。
当多个线程对同一个缓存行拜访时，如其中一个线程锁住缓存行，而后操作，这时其它线程则无奈操作该缓存行。这种状况下，咱们在进行程序代码设计时是要尽量避免的。
4.3 伪共享的躲避
间断紧凑的内存调配带来高性能，但并不代表它始终都卓有成效，伪共享就是无声的性能杀手。所谓伪共享(False Sharing），是因为运行在不同CPU上的不同线程，同时批改处在同一个Cache Line上的数据引起。缓存行上的写竞争是运行在SMP零碎中并行线程实现可伸缩性最重要的限度因素，一般来说，从代码中很难看清是否会呈现伪共享。
在每个CPU来看，各自批改的是不同的变量，但因为这些变量在内存中彼此紧挨着，因而它们处于同一个Cache Line上。当一个CPU批改这个Cache Line之后，为了保证数据的一致性，必然导致另一个CPU的本地Cache的有效，因此触发Cache miss，而后从内存中从新加载变量被批改后的值。多个线程频繁的批改处于同一个Cache Line的数据，会导致大量的Cache miss，因此造成程序性能的大幅降落。
下图阐明了两个不同Core的线程更新同一缓存行的不同信息项：
上图阐明了伪共享的问题。在Core1上运行的线程筹备更新变量X，同时Core2上的线程筹备更新变量Y。然而，这两个变量在同一个缓存行中。每个线程都要去竞争缓存行的所有权来更新变量。如果Core1取得了所有权，缓存子系统将会使Core2中对应的缓存行生效。当Core2取得了所有权而后执行更新操作，Core1就要使本人对应的缓存行生效。来来回回的通过L3缓存，大大影响了性能。如果相互竞争的Core位于不同的插槽，就要额定横跨插槽连贯，问题可能更加重大。
1) 躲避解决形式
l 增大数组元素的距离使得不同线程存取的元素位于不同cache line，空间换工夫
l 在每个线程中创立全局数组各个元素的本地拷贝，而后完结后再写回全局数组
2) 代码示例阐明
示例3，(JAVA)
从代码设计角度，要思考分明类构造中哪些变量是不变，哪些是常常变动，哪些变动是齐全互相独立，哪些属性一起变动。如果业务场景中，上面的对象满足几个特点
public class Data{ long modifyTime; boolean flag; long createTime; char key; int value;}l 当value变量扭转时，modifyTime必定会扭转
l createTime变量和key变量在创立后就不会再变动
l flag也常常会变动，不过与modifyTime和value变量毫无关联
当下面的对象须要由多个线程同时拜访时，从Cache角度，当咱们没有加任何措施时，Data
对象所有的变量极有可能被加载在L1缓存的一行Cache Line中。在高并发拜访下，会呈现这种问题：
如上图所示，每次value变更时，依据MESI协定，对象其余CPU上相干的Cache Line全副被设置为生效。其余的处理器想要拜访未变动的数据(key和createTime)时，必须从内存中从新拉取数据，增大了数据拜访的开销。
无效的Padding形式
正确形式是将该对象属性分组，将一起变动的放在一组，与其余无关的放一组，将不变的放到一组。这样当每次对象变动时，不会带动所有的属性从新加载缓存，晋升了读取效率。在JDK1.8前，个别在属性间减少长整型变量来分隔每一组属性。被操作的每一组属性占的字节数加上前后填充属性所占的字节数，不小于一个cache line的字节数就可达到要求。
public class DataPadding{ long a1,a2,a3,a4,a5,a6,a7,a8;//避免与前一个对象产生伪共享 int value; long modifyTime; long b1,b2,b3,b4,b5,b6,b7,b8;//避免不相干变量伪共享; boolean flag; long c1,c2,c3,c4,c5,c6,c7,c8;// long createTime; char key; long d1,d2,d3,d4,d5,d6,d7,d8;//避免与下一个对象产生伪共享}采取上述措施后的图示：
在Java中
Java8实现字节填充防止伪共享， JVM参数 -XX:-RestrictContended
@Contended 位于sun.misc用于注解java 属性字段，主动填充字节，避免伪共享。
示例4，(C语言)
**//****程序 thread1.c** **多线程拜访数据结构的不同字段**#include <stdio.h>#include <pthread.h>struct { int a; // charpadding[64]; // thread2.c代码 int b;}data; void *thread_1(void) { int i = 0; for(i=0; i < 1000000000; i++){ data.a = 0; }}void *thread_2(void) { int i = 0; for(i=0; i < 1000000000; i++){ data.b = 0; }}//程序 thread2.c
Thread1.c 中的红色字体行，关上正文即为 thread2.c
main()函数很简略，创立两个线程并运行,参考代码如下：
pthread_t id1;int ret = pthread_create(&id1,NULL, (void*)thread_1,NULL);编译、运行后果如下：
从测试后果看，第一个程序耗费的工夫是第二个程序的3倍
案例参考：https://www.cnblogs.com/wangh...
后果剖析
此示例波及到Cache Line的伪共享问题。两个程序惟一的区别是，第二个程序中字段a和b两头有一个大小为64个字节的字符数组。第一个程序中，字段a和字段b处于同一个Cache Line上，当两个线程同时批改这两个字段时，会触发Cache Line伪共享问题，造成大量的Cache miss，进而导致程序性能降落。
第二个程序中，字段a和b两头加了一个64字节的数组，这样就保障了这两个字段处在不同的Cache Line上。如此一来，两个线程即使同时批改这两个字段，两个cache line也互不影响，cache命中率很高，程序性能会大幅晋升。
示例5，(C语言)
在设计数据结构的时候，尽量将只读数据与读写数据离开，并具尽量将同一时间拜访的数据组合在一起。这样CPU能一次将须要的数据读入。譬如，上面的数据结构就很不好。
struct __a{ int id; // 不易变 int factor;// 易变 char name[64];// 不易变 int value;// 易变};在 X86 下，能够试着批改和调整它
#define CACHE_LINE_SIZE 64 //缓存行长度struct __a{ int id; // 不易变 char name[64];// 不易变 char __align[CACHE_LINE_SIZE – sizeof(int)+sizeof(name) * sizeof(name[0]) %CACHE_LINE_SIZE] int factor;// 易变 int value;// 易变 char __align2[CACHE_LINE_SIZE –2* sizeof(int)%CACHE_LINE_SIZE ]};CACHE_LINE_SIZE–sizeof(int)+sizeof(name)*sizeof(name[0])%CACHE_LINE_SIZE看起来不谐和，CACHE_LINE_SIZE示意高速缓存行(64B大小)。__align用于显式对齐，这种形式使得构造体字节对齐的大小为缓存行的大小。
4.4 缓存与内存对齐
1）字节对齐
attribute ((packed))通知编译器勾销构造在编译过程中的优化对齐,依照理论占用字节数进行对齐，是GCC特有的语法;
__attribute__((aligned(n)))示意所定义的变量为n字节对齐;
struct B{ char b;int a;short c;}; (默认4字节对齐)
这时候同样是总共7个字节的变量，然而sizeof(struct B)的值却是12。
字节对齐的细节和编译器实现相干，但一般而言，满足三个准则：
1)(构造体)变量的首地址可能被其(最宽)根本类型成员的大小所整除；
2)构造体每个成员绝对于首地址的偏移量都是成员大小的数倍，如有须要,编译器会在成员之间加上填充字节(internal adding)
3)构造体的总大小为构造体最宽根本类型成员大小的数倍，如有须要,编译器会在最末一个成员之后加上填充字节(trailing padding)
2）缓存行对齐
数据逾越两个cache line，意味着两次load或两次store。如果数据结构是cache line对齐的，就有可能缩小一次读写。数据结构的首地址cache line对齐，意味着可能有内存节约(特地是数组这样间断调配的数据结构），所以须要在空间和工夫两方面衡量。比方当初个别的malloc()函数，返回的内存地址会曾经是8字节对齐的，这就是为了可能让大部分程序有更好的性能。
在C语言中，为了防止伪共享，编译器会主动将构造体，字节补全和对齐，对齐的大小最好是缓存行的长度。总的来说，构造体实例会和它的最宽成员一样对齐。编译器这样做是因为这是保障所有成员自对齐以取得疾速存取的最容易办法。
__attribute__((aligned(cache_line)))对齐实现struct syn_str { ints_variable;
};__attribute__((aligned(cache_line)))；
示例6，(C语言)
structsyn_str { int s_variable; };void*p = malloc ( sizeof (struct syn_str) + cache_line );syn_str*align_p=(syn_str*)((((int)p)+(cache_line-1))&~(cache_line-1);4.5 CPU分支预测
代码在内存外面是顺序排列的，能够程序拜访，无效进步缓存命中。对于分支程序来说，如果分支语句之后的代码有更大的执行几率，就能够缩小跳转，个别CPU都有指令预取性能，这样能够进步指令预取命中的几率。分支预测用的就是likely/unlikely这样的宏，个别须要编译器的反对，属动态的分支预测。当初也有很多CPU反对在外部保留执行过的分支指令的后果(分支指令cache)，所以动态的分支预测就没有太多的意义。
示例7，(C语言)
inttestfun(int x){ if(__builtin_expect(x, 0)) { ^^^--- We instruct the compiler, "else" blockis more probable x = 5; x = x * x; } else { x = 6; } return x;}`在这个例子中，x为0的可能性更大，编译后察看汇编指令，后果如下：
`Disassembly of section .text：00000000 <testfun>: 0: 55 push %ebp 1: 89e5 mov %esp,%ebp 3: 8b 45 08 mov 0x8(%ebp),%eax 6: 85 c0 test %eax,%eax 8: 75 07 jne 11 <testfun+0x11> a: b8 06 00 00 00 mov $0x6,%eax f: c9 leave 10: c3 ret 11: b8 19 00 00 00 mov $0x19,%eax 16: eb f7 jmp f <testfun+0xf>`能够看到，编译器应用的是 jne指令，且else block中的代码紧跟在前面
8: 75 07 jne 11 <testfun+0x11>a: b8 06 00 00 00 mov $0x6,%eax4.6 命中率的监控
程序设计要谋求更好的利用CPU缓存，来缩小从内存读取数据的低效。在程序运行时，通常须要关注缓存命中率这个指标。
监控办法(Linux)：查问CPU缓存无命中次数及缓存申请次数，计算缓存命中率
perf stat -e cache-references -e cache-misses
4.7 小 结
程序从内存获取数据时，每次不仅取回所需数据，还会依据缓存行的大小加载一段间断的内存数据到缓存中，程序设计中的优化范式参考如下。
l 在汇合遍历的场景，可应用有序数组，数组在内存中是一段间断的空间;
l 字段尽量定义为占用字节小的类型，如int可满足时，不应用long。这样单次可加载更多的数据到缓存中;
l 对象或构造体大小尽可能设置为CPU外围缓存行的整数倍。基于64B大小的缓存行，如读取的数据是50B，最坏状况下须要两次从内存加载；当为70B时，最坏状况须要三次内存读取，能力加载到缓存中;
l 对同一对象/构造体的多个属性，可能存在于同一缓存行中，导致伪共享问题，需为属性的不变与常变，变动的独立与关联而隔离设计，及缓存行对齐，解决多线程高并发环境下缓存生效、彼此牵制问题；
l CPU有分支预测能力，在应用ifelse case when等循环判断的场景时，能够程序拜访，无效进步缓存的命中
. . . . . .
除了本章节中介绍的案例之外，在零碎中CPU Cache对程序性能的影响随处可见。
点击关注，第一工夫理解华为云陈腐技术~