CSAPP实验3：Cache Lab笔记
实验简介
Cache LAB分为Part A和B两部分，这次实验的任务很明确，就是制作自己的缓存系统，具体来说是
- 实现一个缓存模拟器，根据给定的 trace 文件来输出对应的操作
- 利用缓存机制加速矩阵运算
我们需要修改的是 csim.c（Part A） 和 trans.c（Part B）。编译的时候只需要简单 make clean 和 make，然后就可以进行测试了。
文件说明
Github地址：Cache Lab
- csim.c：实现缓存模拟器的文件
- trans.c：实现矩阵转置的文件
- csim-ref：标准的缓存模拟器
- csim：由你实现的模拟器可执行程序
- tracegen：测试你的矩阵转置是否正确，并给出错误信息
- test-trans：测试你的矩阵转置优化的如何，并给出评分
- driver.py：自动进行测试评分
在每一次更新之后，首先用make生成文件，之后用相应的test跑分即可。
Part A：Writing a Cache Simulator 实现一个缓存模拟器
讲义上首先给我们提供了一个程序示例
linux> valgrind --log-fd=1 --tool=lackey -v --trace-mem=yes ls -l执行，我们可以看到如下面这样的输出：（输入的trace文件的内容）
I 04ead900,3
I 04ead903,3
I 04ead906,5
I 04ead838,3
I 04ead83b,3
I 04ead83e,5
L 1ffefff968,8
I 04ead843,3
I 04ead846,3
I 04ead849,5
L 1ffefff960,8
I 04ead84e,3
I 04ead851,3
......这样的trace文件中记载着每一次对内存的操作，前面的字母代表操作类型，统一的格式是:
[空格][操作类型][空格][内存地址][逗号][大小]其中如果第一个不是空格而是I，则代表加载，没有实际意义。
操作类型有以下三种：
- L：读取，从内存中读取
- S：存储，向内存中存储
- M：修改，这涉及一次读取，一次存储操作
- 地址指的是一个 64 位的 16 进制内存地址；大小表示该操作内存访问的字节数
- 其中I指令无空格，M/S/L指令前有1个空格（解析指令时注意）
然后实验给我们提供了一个程序csim-ref，我们要做的就是写出一个和它功能一样的程序。
Usage: ./csim-ref [-hv] -s <num> -E <num> -b <num> -t <file>
Options:
-h Print this help message.
-v Optional verbose flag.
-s <num> Number of set index bits.
-E <num> Number of lines per set.
-b <num> Number of block offset bits.
-t <file> Trace file.
Examples:
linux> ./csim-ref -s 4 -E 1 -b 4 -t traces/yi.trace
linux> ./csim-ref -v -s 8 -E 2 -b 4 -t traces/yi.trace样例输出：
分析
getopt 获取命令行参数
fscanf 读入trace文件内容
malloc 分配空间给cache
数据访问带来的miss：
- L：Load，数据载入，可能发生1次miss
- S：Store，可能发生1次miss
- M：store后再load，两次访存。1 miss & 1 hit + 可能eviction
所以L/S指令结果是miss或者hit或者miss+eviction；而M指令结果是hit+hit或者miss+hit 或者 miss+eviction+hit
1 Cache结构
设计Cache基本单元为 block，cache由cacheblock组成
typedef struct
{
unsigned tag;
unsigned usedtime;
} block;
block *cache;其中usedtime是判断LRU cache行。初始值为0表示没有用过，相当于invalid。非零值越小代表越少使用，usedtime最大代表刚使用。
2 命令行参数解析
首先对命令行参数进行解析
int getOpt(int argc,char **argv,int *s,int *E,int *b,int *verbose,char *tracefile)
{
int oc;
while((oc=getopt(argc,argv,"hvs:E:b:t:"))!=-1){
switch(oc){
case 'h': printHelpMenu();break; // print usage
case 'v': *verbose=1;break;
case 's': *s = atoi(optarg);break;
case 'E': *E = atoi(optarg);break;
case 'b': *b = atoi(optarg);break;
case 't': strcpy(tracefile,optarg);break;
default : printf("input error\n");break;
}
}
return 0;
}3 初始化cache
然后初始化cache： E<
cache = (block *)malloc(sizeof(block)* E<memset(cache,0,sizeof(block)* E< 4 读取文件参数
fscanf读取trace文件中的指令、地址
fp = fopen (tracefile,"r");
while(fscanf(fp,"%s%x,%d\n",op,&addr,&size) > 0){
if(verbose)
printf("%s %x,%d ",op,addr,size);
switch(op[0]){
case 'M': hit++;
case 'L':
case 'S': find(op[0],addr,size,++t);
}
}5 数据访问
获取tag和 set index
unsigned tag = addr >>b >>s ;
unsigned set_index = addr >> b &((1<1); 找到对应的set
block *cache_set = cache + E * set_index ; // set address
block *eviction_block = cache_set; // LRU cacheline进行数据查找，其中eviction_block表示查询过程中LRU的cache行，也就是usedtime最小的（但是非0）在一个set里面遍历cache行
- 如果
usedtime！=0且tag匹配：hit - 如果
usedtime=0，是个空block，使用这个block：miss - 如果
usedtime！=0，tag不匹配，跟eviction_block.usedtime比较，如果时间更小，更新eviction_block=该cacheblock
如果循环结束，也就证明这个set的所有cache行都满了，就替换LRU cache行。
void find(char op, unsigned addr,unsigned size,int time){
int i;
unsigned tag = addr >>b >>s ;
unsigned set_index = addr >> b &((1<1);
block *cache_set = cache + E * set_index ; // set address
block *eviction_block = cache_set; // LRU cacheline
for(i = 0;iif(cache_set[i].usedtime>0 && cache_set[i].tag ==tag){ //hit
cache_set[i].usedtime = time;
hit++;
if(verbose) cacheStateOut(op,0);
return;
}
else if(!cache_set[i].usedtime){ // empty block
miss++;
cache_set[i].tag = tag;
cache_set[i].usedtime = time;
if(verbose) cacheStateOut(op,1);
return;
}
else if(cache_set[i].usedtime < eviction_block->usedtime) // !=tag , current block is older
eviction_block = cache_set+i;
}
miss ++;
eviction ++;
eviction_block->tag = tag; // replace sacrifice cacheline
eviction_block->usedtime = time;
if(verbose) cacheStateOut(op,2);
return ;
} 测试
结果正确
Part B：Optimizing Matrix Transpose 优化矩阵转置
要求优化对不同规格的矩阵的转置操作。 这里有三个矩阵，他们的miss次数要求分别如下：
- 32 * 32: 8 points if m < 300, 0 points if m > 600
- 64 × 64: 8 points if m < 1300, 0 points if m > 2000
- 61 × 67: 10 points if m < 2000, 0 points if m > 3000
要求
- 在tranc.c里进行完成 transpose_submit函数
- 最多使用12个int型变量，不能使用数组和malloc函数，不能使用位运算，不能改变矩阵A
Tips
题目的cache参数如下：s=5，E=1，b=5
- 是一个直接映射高速缓存
- 32字节的Block size
- 有32个set
分析
首先要明确，尽管矩阵的转置本身导致对于A矩阵（原始矩阵）的读和B矩阵（转置矩阵）的写不可能同时为连续的（即不可能同时存在连续读和连续写——对A矩阵行的连续读必然导致对B矩阵列的非连续写）。 但只要矩阵的大小小于缓存的总大小，那么在理想的情况下，在最初的强制不命中（即缓存为空导致的不命中）后，整个矩阵都会被加载进入缓存。在这之后的所有对于B矩阵的不连续写的引用都会命中。
在该实验中，缓存采用的是直接映射高速缓存，s = 5，b = 5，E = 1。对于该缓存，总共存在32个组，每个组共32个字节，可以装入8个int型变量，是非常有限的缓存，矩阵大小>cache大小。主要需要解决以下两个问题：
- 直接映射缓存所带来的冲突不命中。观察程序中矩阵存储的位置即可以发现，矩阵A和矩阵B的同一行实际上被映射到了同一个缓存组。当进行对角线的引用时，一定会发生缓存的冲突不命中。需要仔细地处理对角线上的元素。
- 所需优化的矩阵的总大小超出了缓存的总大小。必然导致程序的访存效率低下。
为了解决第一个问题，我们需要仔细地考虑对于矩阵访问顺序；第二个问题，采用矩阵的分块（Blocking）方法降低miss
矩阵分块的目的在于将大的、不能完全加载进入缓存的大矩阵分块成小的、可以完全加载进入缓存的小矩阵块来处理。小矩阵块具有良好的局部性，性能显著增加。 但同时也要注意，分块使得程序的可阅读性大大降低，因此一般只在常用的库函数中采用分块优化。
32 * 32
对于32 * 32的矩阵，一次可以装下8行的值。于是我们用8 * 8的分块来处理，增加缓存命中。
在32*32的情况中，一行是32个int，也就是4个block，所以cache可以存8行，由此可以推出映射冲突的情况：只要两个int之间相差8行的整数倍，那么读取这两个元素所在的block就会发生替换
但是转置的过程中这样的情况会发生吗？不会。图中的BCD三点对于A来说仅仅是行差了8K，这在转置中是不可能发生的！因为转置是将A[i][j]送到B[j][i]，不会有B[i+8k][j]的情况出现（不会在行相差8整数倍的块中，除非对角线上的块）。所以B在写入时miss概率也是1/8（强制失效）。
一个cache block只有32个Byte，可以装下8个int。这个cache可以容纳矩阵的前8行。所以分块采用8 * 8合适。先读取A的一行，然后放入B的一列。12个int变量，4个用来循环，其余8个用来存A中块的一行。
简单8 * 8分块：
if(M == 32){
for (i = 0; i < N; i+=8) {
for (j = 0; j < M; j+=8) {
for(k = i ;k < i + 8 && kfor(l = j ; l < j + 8 && l < M;l++)
{
a0 = A[k][l];
B[l][k] = a0;
}
}
}
}
} 测试结果如下：超过了300miss，原因是对角线访问问题
对角线上的block访问miss问题：
矩阵A和矩阵B的同一行实际上被映射到了同一个cache block。当进行对角线的引用时，一定会发生缓存的冲突不命中。并且，由于A和B的元素时一个一个处理的，必定会造成反复多次的冲突不命中。（如下图A第一个元素读miss，B第一个元素存miss，A读第二个元素miss）
解决方法：通过变量一次性读出A的一整行，再存入B
cache miss分析
（经过对角线块优化后）对于32 × 32的矩阵，总共存在1024次读(32*32)和1024次写。
对于非对角线的分块（总共12个），其缓存不命中率是1/8（仅强制不命中）；
对于对角线的分块（总共4个），A读缓冲不命中率1/8（仅强制不命中），B写不命中率1/4（强制失效 1/8 + 冲突不命中 1/8（A刚读的那行B写的时候会miss））
因此，理论上优化之后的总缓存不命中数为2048 × 0.75 × 0.125 + 1024 × 0.25 × 0.125 + 1024 × 0.25 × 0.25 = 288次。最后跑出来的答案是287，非常接近。
for (i = 0; i < N; i+=8) {
for (j = 0; j < M; j+=8) {
if(i == j){
for(k = i ;k < i + 8 && k1];
a2 = A[k][j+2];
a3 = A[k][j+3];
a4 = A[k][j+4];
a5 = A[k][j+5];
a6 = A[k][j+6];
a7 = A[k][j+7];
B[j][k] = a0;
B[j+1][k] = a1;
B[j+2][k] = a2;
B[j+3][k] = a3;
B[j+4][k] = a4;
B[j+5][k] = a5;
B[j+6][k] = a6;
B[j+7][k] = a7;
}
}
else{
for(k = i ;k < i + 8 && kfor(l = j ; l < j + 8 && l < M;l++)
B[l][k] = A[k][l];
}
}
}
} 测试结果：287miss
64 * 64
这题难度是最大的，miss必须1300以下
首先考虑Cache中只能放4行A中的行，如果再用8×8的块，前面4行可以填入，后面4行会在Cache中发生冲突，导致miss次数增加。
如果只用4×4的块呢？那么每次Cache中放入8个int，我们却只用4个，浪费严重，这个方法最少也只能做到1677次miss。
题目说不能对A进行操作，但是可以对B进行操作！将B作为缓存使用
改进方法：将8 * 8 块再分成4个4 * 4的块进一步处理，经过改进，达到1171miss
首先对左上角和右上角进行处理：
- B左上角 = A左上角转置。B右上角=A右上角转置。
- 我们最后只需要把这部分平移到B的左下角就好。
现在B左上角完成
- 首先用四个变量存储A的左下角的一列。
- 再用四个变量存储B的右上角的一行。
- 把四个变量存储的A的左下角的一列移动到B右上角的一行
- 把四个变量存储的B的右上角的一行平移到B左下角的一列
- B的右下角=A的右下角转置
关键的操作在第二步
for (i = 0; i < N; i += 8) {
for (j = 0; j < M; j += 8) {
for (k = i; k < i + 4; k++) {
a0 = A[k][j];
a1 = A[k][j + 1];
a2 = A[k][j + 2];
a3 = A[k][j + 3];
a4 = A[k][j + 4];
a5 = A[k][j + 5];
a6 = A[k][j + 6];
a7 = A[k][j + 7];
B[j][k] = a0;
B[j + 1][k] = a1;
B[j + 2][k] = a2;
B[j + 3][k] = a3;
B[j][k + 4] = a4;
B[j + 1][k + 4] = a5;
B[j + 2][k + 4] = a6;
B[j + 3][k + 4] = a7;
}
for (l = j + 4; l < j + 8; l++) {
a4 = A[i + 4][l - 4]; // A left-down col
a5 = A[i + 5][l - 4];
a6 = A[i + 6][l - 4];
a7 = A[i + 7][l - 4];
a0 = B[l - 4][i + 4]; // B right-above line
a1 = B[l - 4][i + 5];
a2 = B[l - 4][i + 6];
a3 = B[l - 4][i + 7];
B[l - 4][i + 4] = a4; // set B right-above line
B[l - 4][i + 5] = a5;
B[l - 4][i + 6] = a6;
B[l - 4][i + 7] = a7;
B[l][i] = a0; // set B left-down col
B[l][i + 1] = a1;
B[l][i + 2] = a2;
B[l][i + 3] = a3;
B[l][i + 4] = A[i + 4][l];
B[l][i + 5] = A[i + 5][l];
B[l][i + 6] = A[i + 6][l];
B[l][i + 7] = A[i + 7][l];
}
}
}测试结果：1171miss 通过
61 * 67
不规则的matrix，本质也是用分块来优化Cache的读写，但是不能找到比较显然的规律看出来间隔多少可以填满一个Cache。但是由于要求比较松，因此无需考虑处理对角线，直接进行转置操作，仅尝试换用不同的边长分块即可。16 × 16的分块已可以保证满分。
测试：1992miss <2000
自动评分脚本输出：
zjw@ubuntu:~/Desktop/cachelab-handout$ ./driver.py
Part A: Testing cache simulator
Running ./test-csim
Your simulator Reference simulator
Points (s,E,b) Hits Misses Evicts Hits Misses Evicts
3 (1,1,1) 9 8 6 9 8 6 traces/yi2.trace
3 (4,2,4) 4 5 2 4 5 2 traces/yi.trace
3 (2,1,4) 2 3 1 2 3 1 traces/dave.trace
3 (2,1,3) 167 71 67 167 71 67 traces/trans.trace
3 (2,2,3) 201 37 29 201 37 29 traces/trans.trace
3 (2,4,3) 212 26 10 212 26 10 traces/trans.trace
3 (5,1,5) 231 7 0 231 7 0 traces/trans.trace
6 (5,1,5) 265189 21775 21743 265189 21775 21743 traces/long.trace
27
Part B: Testing transpose function
Running ./test-trans -M 32 -N 32
Running ./test-trans -M 64 -N 64
Running ./test-trans -M 61 -N 67
Cache Lab summary:
Points Max pts Misses
Csim correctness 27.0 27
Trans perf 32x32 8.0 8 287
Trans perf 64x64 8.0 8 1171
Trans perf 61x67 10.0 10 1992
Total points 53.0 53
Referrence
http://zxcpyp.com/csapp/2017/11/20/Cache-Lab#part-awriting-a-cache-simulator-%E5%AE%9E%E7%8E%B0%E4%B8%80%E4%B8%AA%E7%BC%93%E5%AD%98%E6%A8%A1%E6%8B%9F%E5%99%A8