13 KiB

Raw Blame History

Cache Lab

10225501432 邓博昊

Part A

要求：实现一个缓存模拟器，根据给定的 trace 文件来输出对应的操作

讲义提供了一个程序示例,在安装valgrind后,使用如下命令

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指令之前需添加一个空格用于解析指令。

随后，实验为我们提供了一个名为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

Cache结构

设计Cache基本单元为 block，cache由cacheblock组成

typedef struct 
{
    unsigned tag;
    unsigned usedtime;
} block;
block *cache;

其中usedtime是判断LRU cache行。初始值为0表示没有用过，相当于invalid。非零值越小代表越少使用，usedtime最大代表刚使用。

命令行参数解析

首先对命令行参数进行解析

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;
}

初始化cache

然后初始化cache

cache = (block *)malloc(sizeof(block)* E<<s);
memset(cache,0,sizeof(block)* E<<s);

读取文件参数

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);     
  }
}

数据访问

获取tag和 set index

unsigned tag = addr >>b >>s ;
unsigned set_index = addr >> b &((1<<s) -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<<s) -1);
    block *cache_set = cache + E * set_index ;  // set address
    block *eviction_block = cache_set;            // LRU cacheline
    for(i = 0;i<E;i++){
        if(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

Part B 要我们实作矩阵转置，并将 cache miss 尽可能降低，Part B 的程序限制如下

在 stack 中至多 12 个整数型态的局部变量
不得使用 long 或位操作，将 2 个整数型态变量存在 1 个变量中
不得使用递归
不得修改矩阵 A ，但可以修改矩阵 B
不得自定义矩阵或使用对变量动态配置内存空间malloc

缓存参数

缓存取大小 1KB
采用直映射（E=1)
Block 大小为 32 Byte（b=5)
Set 共 32 组（s=5)

Eviction 的策略

矩阵 A & B 的第一行在 cache 中为同一组
对角线元素互相 evict

测试矩阵大小及分数

32 x 32： cache miss < 300 满分
64 x 64： cache miss < 1300 满分
61 x 67： cache miss < 2000 满分

分析：

在该实验中，缓存采用的是直接映射高速缓存，s = 5，b = 5，E = 1。对于该缓存，总共存在32个组，每个组共32个字节，可以装入8个int型变量，是非常有限的缓存，矩阵大小>cache大小。

主要需要解决以下两个问题：

直接映射缓存所带来的冲突不命中。观察程序中矩阵存储的位置即可以发现，矩阵A和矩阵B的同一行实际上被映射到了同一个缓存组。当进行对角线的引用时，一定会发生缓存的冲突不命中。需要仔细地处理对角线上的元素。
所需优化的矩阵的总大小超出了缓存的总大小。必然导致程序的访存效率低下。

为了解决第一个问题，我们需要仔细地考虑对于矩阵访问顺序；第二个问题，采用矩阵的分块（Blocking）方法降低miss

32 * 32

缓存一个块的大小为 32 Bytes，可放入 8 个整数类型，又整个缓存有 32 组，代表缓存一次可以存放 32 x 8 = 256 个连续位置的整数。对于32 x 32的矩阵来说，等于每8列（256/32）就会发生冲突，因此理想的分块大小应该为8 x 8

另外，因为假设为直接映射，每组都只有一行，等于说只要发生冲突一定有 eviction，代表我们必需尽可能降低行替换的次数。作业特别说明对角线元素互相evict，我们画图观察转置对角线元素会发生什么情况，为了简化以4 x 4的状况来呈现

T1：第一次置换，都是 cache miss
T2：第二次置换，A 是 cache hit，但 B 矩阵第二行不在快取中为 cache miss
T3：第二次置换，为了将 B 矩阵第二行读进快取，必需将 A 矩阵第二行替换掉
T4：第三次置换，因为 T3 替换了 A 矩阵第二行，在 T4 又必需加载回来

从以上分析可以发现，快取在A &B对角线元素的那一行发生冲突，所以对角线元素的替换会产生2次的miss及eviction。

简单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 && k<N;k++){
                        for(l = j ; l < j + 8 && l < M;l++)
                        {                            
                            a0 = A[k][l];
                            B[l][k] = a0;
                        }
                }
            }
        }
    }

测试结果超过了300miss，原因是对角线访问冲突问题

对角线访问冲突问题

矩阵A和矩阵B的同一行实际上被映射到了同一个cache block。当进行对角线的引用时，一定会发生缓存的冲突不命中。并且，由于A和B的元素时一个一个处理的，必定会造成反复多次的冲突不命中。（如下图A第一个元素读miss，B第一个元素存miss，A读第二个元素miss）

解决方法：通过变量一次性读出A的一整行，再存入B

for (i = 0; i < N; i+=8) {
            for (j = 0; j < M; j+=8) {
                if(i == j){
                    for(k = i ;k < i + 8 && k<N;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+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 && k<N;k++){
                        for(l = j ; l < j + 8 && l < M;l++)
                            B[l][k] = A[k][l];
                    }
                }
            }
        }

64 * 64

方法：将8 * 8 块再分成4个4 * 4的块进一步处理

首先对左上角和右上角进行处理：

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];
            }
        }
    }

61 * 67

对于不规则的矩阵，其核心依然是通过分块的方式优化Cache的读写效率。然而，要找到非常明显的规律来判断何时能填满一个Cache却并非易事。鉴于要求较为宽松，我们无需考虑处理对角线的情况，而是直接执行转置操作。只需尝试并更换不同的边长分块就能达到期望效果。实际上，采用16 × 16的分块规模就足以确保获得满分。

13 KiB Raw Blame History