为什么80%的码农都做不了架构师？>>> 
首先言明，本文严格意义上将不能算作原创，因为我写这些东西只不过是博客 Gallery of Processor Cache Effect的学习心得，不能将版权划到自己名下，毕竟咱不是喜欢45度角仰望天空的郭四姑娘。由于原文是英文版，而且作者用的是C++。原文提到的实验，我做了一部分，加深了对Cache的理解。英文比较好的兄弟就不必听我聒噪了，直接点链接看原文好了。
OK，继续我们的探索之旅。深入理解cache（1）得到了我的PC的cache参数如下:
L1 Cache : 32KB , 8路组相连，linesize为 64Byte 64个组
L2 Cache：256KB 8路组相连，linesize为 64Byte 512个组
L3 Cache： 3MB 12路组相连，linesize为 64Byte 4096个组
EAX (55h) Instruction TLB: 2-MB or 4-MB pages, fully associative, 7 entries (03h) Data TLB: 4-KB Pages, 4-way set associative, 64 entries (5Ah) Data TLB0: 2-MB or 4-MB pages, 4-way associative, 32 entries (01h) Instruction TLB: 4-KB Pages, 4-way set associative, 32 entries EBX: (F0h) 64-byte Prefetching (B2h) Instruction TLB: 4-KB pages, 4-way set associative, 64 entries (DDh) 3rd-level cache: 3-MB, 12-way set associative, 64-byte line size EDX: (09h) 1st-level Instruction Cache: 32-KB, 4-way set associative, 64-byte line size (CAh) Shared 2nd-level TLB: 4-KB pages, 4-way set associative, 512 entries (21h) 256KB L2 (MLC), 8-way set associative, 64-byte line size (2Ch) 1st-level data cache: 32-KB, 8-way set associative, 64-byte line size、
1 测试cache的linesize
代码看起来有点长，但是分成了3段。先看第一个测试，测试cache的linesize。
我们知道，cache的迁移是以linesize为单位的，所以，用户纵然只访问一个int，PC需要从主存拷贝1条line 进入Cache，对于我的电脑来说，就是copy 64B。
看下面的代码，测试linesize，如果K=1，遍历整个数组，如果K=16，只访问16倍数位置的值。依次类推。如果K=16，乘法的个数是K=1的时候1/16。我们可以推测，K=16的时候，程序执行时间是K=1的时候的1/16左右。是不是这样的。看下第一个测试用例的结果。
- int test_cache_linesize(int array[],int len,int K)
- {
- int i;
- for( i = 0;i<len;i += K)
- {
- array[i] *=3;
- }
- return 0;
- }
当K = 1 ，2，4 ......16的时候，虽然计算乘法的次数相差很大，但是，代码执行的时间是相近的都是80ms附近，但是当K = 32，64的时候，随着计算乘法的次数减半，代码执行的时间也减半。
原因在于，16 = （linesize）/sizeof（int）= 64/4，当K <16的时候，第一个int不命中，接下来的都命中的，乘法的个数虽然减半，但是从主存向Cache拷贝数据并没有减半。乘法消耗的指令周期要远低于从主存往cache里面copy数据，所以当K<16 的时候，既然从主存Cp数据到Cache的次数是相同的，那么总的执行时间差距不大就可以理解了。
当K>16的时候，每次都需要去主存取新的line，所以步长K增大一倍，去主存copy数据到cache的次数就减少为原来的一半，所以运行时间也减少为 原来的1半。
2 Cache的大小。
我的PC 有三级Cache，容量分别是32K 256K ,3M .这些参数对程序有什么影响呢。
下面的测试代码，执行的次数是一样的，都是64M次但是array的大小不一样。我们分别传入参数为1K，2K ，4K ,8K.....64MB 。在执行之前我们先分析下。
目前，如果array的大小是多大，循环执行的次数是一样的。我们的1级Cache大小是32KB，也就是最多容纳8192个int。如果我们的数组大小就是8192个int，那么除了第一次执行需要将数据从 主存-->L3 Cache--->L2 Cache -->L1 Cache传上来，后面再次执行的时候，由于整个数组全在L1 Cache，L1 Cache命中，速度很快。当然如果数组大小小于8192个int，L1更能容纳的下。8192是个坎。数组大于8192个int，性能就会下降一点。
如果我们的array大小大于L1 cache容量会怎样呢？看下我们的L2 Cache，大小256KB，即64K个int，换句话说，如果数组长度小于64K个int，也不赖，至少L2 Cache 容纳的下，虽然L1 Cache每写满32KB就需要将交换出去。换句话说，64K是个坎，数组大于64K个int，性能就会下降。
L3Cache我就不说，毕竟我不是唐僧，一样的情况，对于我的3M 缓存，3M/4 = 768K 是个坎，如果数组大于768个int，那么性能又会下降。
好了可以看下面的图了，和我们想的一样，
当低于8192的时候，都是120ms 左右，
[8192,64K ]的时候，都是200ms 左右
[64K ,768K ]的时候，都是300ms左右
大于768的时候，1200ms左右。
- int test_cache_capacity(int array[],int cap)
- {
- int i;
- int lenmod = cap -1;
- int times = 64*SIZE_1MB;
- for(i = 0;i<times;i++)
- {
- array[(i*16) & (lenmod)]++;/*16 means linesize/sizeof(int) = 16*/
- }
- return 0;
- }
第三部分我就不讲了，源代码给出大家可以自己在电脑上研究。不过第三部分要比较难懂，而且我前面提到的那篇讲的也不是很好懂。
下面是我的测试全代码
/* http://igoro.com/archive/gallery-of-processor-cache-effects/ */
#include<stdio.h>
#include<stdlib.h>
#include<linux/types.h>
#include<string.h>
#define SIZE_1KB (1024)
#define SIZE_1MB (1024*1024)
#define NUMBER 64*SIZE_1MB
#define MILLION 1000000
__u64 rdtsc()
{
__u32 hi;
__u32 lo;
__asm__ __volatile__
(
"rdtsc":"=a"(lo),"=d"(hi)
);
return (__u64)hi<<32|lo;
}
__u64 gettime()
{
struct timeval tv;
gettimeofday(&tv,NULL);
return ((__u64)(tv.tv_sec))*MILLION+tv.tv_usec;
}
int test_cache_linesize(int array[],int len,int K)
{
int i;
for( i = 0;i<len;i += K)
{
array[i] *=3;
}
return 0;
}
int test_cache_capacity(int array[],int cap)
{
int i;
int lenmod = cap -1;
int times = 64*SIZE_1MB;
for(i = 0;i<times;i++)
{
array[(i*16) & (lenmod)]++;/*16 means linesize/sizeof(int) = 16*/
}
return 0;
}
int test_cache_associative(int array[],int size,int K)
{
int i;
int cur =0;
__u64 begin;
__u64 end;
begin =gettime();
for( i = 0;i<SIZE_1MB;i++)
{
array[cur]++;
cur += K;
if(cur >= size)
cur = 0;
}
end = gettime();
printf("when size = %10d, K = %10d : test_cache_associative cost %14llu us\n",
size,K ,end-begin);
return 0;
}
int test_cache()
{
int *array = NULL;
array = malloc(NUMBER*sizeof(int));
__u64 begin ;
__u64 end;
int i;
int K;
int cap ;
int size;
if(array == NULL)
{
printf("malloc space for array failed \n");
return -1;
}
for(i = 0;i<NUMBER;i++)
{
array[i] = i;
}
printf("---------test cache linesize-------------------------------------------\n");
for(K = 1;K < 64*1024;K *= 2)
{
begin = gettime();
test_cache_linesize(array,NUMBER,K);
end = gettime();
printf("when K = %10d,multiply %10d times,cost %14llu us,average cost %llu us\n",
K,NUMBER/K,end - begin,(end-begin)/(NUMBER/K));
if(K == 1)
{
begin = gettime();
test_cache_linesize(array,NUMBER,K);
end = gettime();
printf("when K = %10d,multiply %10d times,cost %14llu us,average cost %llu us\n",
K,NUMBER/K,end - begin,(end-begin)/(NUMBER/K));
}
}
printf("-----------test cache capacity-------------------------------------------\n");
for(cap = 1024;cap <= NUMBER;cap *= 2)
{
begin =gettime();
test_cache_capacity(array,cap);
end = gettime();
printf("when cap = %10d,cost %14llu us\n",
cap,end-begin);
if(cap == 2*SIZE_1MB/sizeof(int))
{
begin =gettime();
test_cache_capacity(array,3*SIZE_1MB/sizeof(int));
end = gettime();
printf("when cap = %10d,cost %14llu us\n",
3*SIZE_1MB/sizeof(int),end-begin);
}
}
printf("-----------test cache associative ---------------------------------------\n");
for(size = 1*SIZE_1MB;size >= 4*SIZE_1KB;size /= 2)
{
for(K = 64;K <= 576 ;K += 64)
{
test_cache_associative(array,size,K);
}
}
free(array);
return 0;
}
int main()
{
test_cache();
return 0;
}
#include<stdio.h>
#include<stdlib.h>
#include<linux/types.h>
#include<string.h>
#define SIZE_1KB (1024)
#define SIZE_1MB (1024*1024)
#define NUMBER 64*SIZE_1MB
#define MILLION 1000000
__u64 rdtsc()
{
__u32 hi;
__u32 lo;
__asm__ __volatile__
(
"rdtsc":"=a"(lo),"=d"(hi)
);
return (__u64)hi<<32|lo;
}
__u64 gettime()
{
struct timeval tv;
gettimeofday(&tv,NULL);
return ((__u64)(tv.tv_sec))*MILLION+tv.tv_usec;
}
int test_cache_linesize(int array[],int len,int K)
{
int i;
for( i = 0;i<len;i += K)
{
array[i] *=3;
}
return 0;
}
int test_cache_capacity(int array[],int cap)
{
int i;
int lenmod = cap -1;
int times = 64*SIZE_1MB;
for(i = 0;i<times;i++)
{
array[(i*16) & (lenmod)]++;/*16 means linesize/sizeof(int) = 16*/
}
return 0;
}
int test_cache_associative(int array[],int size,int K)
{
int i;
int cur =0;
__u64 begin;
__u64 end;
begin =gettime();
for( i = 0;i<SIZE_1MB;i++)
{
array[cur]++;
cur += K;
if(cur >= size)
cur = 0;
}
end = gettime();
printf("when size = %10d, K = %10d : test_cache_associative cost %14llu us\n",
size,K ,end-begin);
return 0;
}
int test_cache()
{
int *array = NULL;
array = malloc(NUMBER*sizeof(int));
__u64 begin ;
__u64 end;
int i;
int K;
int cap ;
int size;
if(array == NULL)
{
printf("malloc space for array failed \n");
return -1;
}
for(i = 0;i<NUMBER;i++)
{
array[i] = i;
}
printf("---------test cache linesize-------------------------------------------\n");
for(K = 1;K < 64*1024;K *= 2)
{
begin = gettime();
test_cache_linesize(array,NUMBER,K);
end = gettime();
printf("when K = %10d,multiply %10d times,cost %14llu us,average cost %llu us\n",
K,NUMBER/K,end - begin,(end-begin)/(NUMBER/K));
if(K == 1)
{
begin = gettime();
test_cache_linesize(array,NUMBER,K);
end = gettime();
printf("when K = %10d,multiply %10d times,cost %14llu us,average cost %llu us\n",
K,NUMBER/K,end - begin,(end-begin)/(NUMBER/K));
}
}
printf("-----------test cache capacity-------------------------------------------\n");
for(cap = 1024;cap <= NUMBER;cap *= 2)
{
begin =gettime();
test_cache_capacity(array,cap);
end = gettime();
printf("when cap = %10d,cost %14llu us\n",
cap,end-begin);
if(cap == 2*SIZE_1MB/sizeof(int))
{
begin =gettime();
test_cache_capacity(array,3*SIZE_1MB/sizeof(int));
end = gettime();
printf("when cap = %10d,cost %14llu us\n",
3*SIZE_1MB/sizeof(int),end-begin);
}
}
printf("-----------test cache associative ---------------------------------------\n");
for(size = 1*SIZE_1MB;size >= 4*SIZE_1KB;size /= 2)
{
for(K = 64;K <= 576 ;K += 64)
{
test_cache_associative(array,size,K);
}
}
free(array);
return 0;
}
int main()
{
test_cache();
return 0;
}