计算机体系结构cache模拟器实验报告Word下载.docx

计算机体系结构cache模拟器实验报告Word下载.docx

《计算机体系结构cache模拟器实验报告Word下载.docx》由会员分享，可在线阅读，更多相关《计算机体系结构cache模拟器实验报告Word下载.docx（16页珍藏版）》请在冰豆网上搜索。

accesscount

请求次数

待输出

等于project.txt的值个数

hitcount

命中次数

成功在Cache找到次数

hitrate

命中率

HitRate=hitcount/accesscount

misscount

未命中次数

没在Cache找到次数

misscount=1-hitcount

missrate

未命中率

MissRate=misscount/accesscount

c1c,c2c,c3c

失效次数

分别为三种失效类型的次数

（2）程序内部主要参数：

（代码内部重要参数）

计算

blockinbyte

块的字节大小

=blocksize*4

每一个块占多少字节

NOofblock

块个数

=cachesize/blockinbyte

Cache中多少个块

NOofset

组个数

=NOofblock/assoc

块分成了多少个组

bytearray[]

要访问的数据的字节地址

=projec.txt中的值

project.txt文件数据赋给了bytearray[]数组

wordaddress[]

要访问的数据的字地址

=bytearray[j]/4

blocksize是字为单位的，就是说一个block占多少个字，所以数据也要求字地址

blockaddress[]

数据的块地址

=wordaddress[]/blocksize

数据在第几块

index

索引位（组地址）

=blockaddress[j]%NOofset

若Noofset=2^m，则块地址低m位为索引位（组地址）。

tag

标识位（组内寻址）

=blockaddress[j]/NOofset

块地址高（32-m）位为标识位,用于确定组内哪块数据，newarray[index][z+1]中存放

*valid

有效位

有效为1，失效为0

判断该cache块数据是否有效*是因为没有真正定义，只是存放newarray[index][z]中

lru[index][z]

最近未被使用次数

每次加1，被重写置0

替换时，替换掉lru[index][]值最大的那个块

2、关键算法

注：

这里不粘贴代码，只是进行简单的代码算法说明

（1）块地址表示：

图是我按照自己的想法自己画的，可能有些地方并不准确，望老师指正。

图中以一个例子来解释cache模拟器中block和数据地址的关系，以及和组地址和标志位的关系。

（2）Index与tag：

由上面计算：

index=blockaddress%NOofsetindex=16%8=2

tag=blockaddress/Noofsettag=16/8=2

以上例，字地址16为例，写成二进制为00010010B，其中组数为8，又因为2^3=8，所以字地址取后3位为：

index=010B=2，取前29位为：

tag=0…0010B=2。

所以，算法与理论是一致的。

（3）Valid：

有效位。

当通过上述方式寻址找到了数据存放的数据块，接下来判断有效位：

有效位为1，说明数据是有效的，可以从block提取数据；

有效位为0，说明块里的数据是无效的，所以不能从block提取数据，出现miss，此时判断miss类型，同时需要访问内存或下一级存储，将数据放到cache里。

（4）失效类型及判断方法：

判断失效类型，函数misstype（intba，intnb，intl）。

Compulsorymiss（强制性失效，冷启动）：

当第一次访问某一个块的时候，数据是肯定不在块中的，此时出现强制性失效，或者说是冷启动失效。

Capacitymiss（容量失效）：

所需的数据不能全部调入cache中，块被替换后又被重新访问，意思就是当所有的块都被占满了，这样又有数据希望被调入缓存时，就出现了容量失效。

Conflictmiss（冲突失效）：

在组相联或直接映像中，数据想要替换进某一组中，组内的块都被占满了，但是别的组的块有空余，数据只能替换这一组，尽管别的组有空余也不能替换。

这样就出现了冲突失效。

（5）LRU算法实现替换：

LRU替换算法是采用最近最久未使用的块，其中Lru[][]数组存放最近多少次未被使用，因为是采用循环访问，当循环访问到这一组时，把这组所有的块的Lru[][]值都加1，如果成功访问到这一块，数据能从其中取出来，就把这一块的Lru[][]值置0，退出循环。

（6）直接映射、组相联映射、全相联映射：

直接映射：

是特殊的组相联映射，就是相联度为1的组相联映射。

所以采取和组相联一样的程序和算法，当识别该组第一块失效时，直接进行替换，因为有且只有一块。

组相联映射：

当识别该组某块失效时，如果块都被占满，要根据Lru[][]值的大小，判断哪一块被替换掉。

全相联映射：

从上到下cache块存数据，则从上到下循环即可，遇到失效时，要根据Lru[][]值的大小，判断哪一块被替换掉。

二、课后习题

1、习题内容

在CacheSimulator模拟器上模拟如下程序的运行过程：

inti,j,cstride,array[256]

for（i=0;

i<

10000;

i++）

for（j=0;

j<

256;

j=j+stride）

c=array[j]+5;

假设Cache总大小是256个字节，且块大小为16字节（4个字）。

同时假设内存当中只有这一个程序在运行，而且整形数字的长度为一个字长（字长为32位），在直接相连映射下，stribe分别等于132、131时程序的运行结果，并分析原因。

而当采用两路组相连时又会有什么结果并分析原因。

2、题目分析

当stribe=132/131时，程序相当于循环访问内存偏移地址为0和地址132/131的内容，循环10000次，也就是访问了2000次存储。

结合cache机制，cache大小为256个字节，块大小为16个字节，所以块的个数为256/16=16个。

若为2路组相连，则有16/2=8组。

当第一次访问块时，一定会发生强制性失效，计一次miss。

3、计算及结果

1）直接映像时：

●stride=132

array[0]的块地址为0，映射到cache的块号为0：

0mod16=0

array[132]的块地址为132/4=33，映射到cache的块号为1：

33mod16=1

因为第一次访问cache，0和1一定会发生强制性失效，之后因为调入cache，不会发生失效。

则失效次数为2，则失效率为：

2/20000=0.01%

命中次数为19998次，命中率为：

19998/20000=99.99%=1（近似）

失效类型为强制性失效，次数为2。

●stride=131

0modulo16=0

array[131]的块地址为131/4=32，映射到cache的块号为0：

32modulo16=0

因为第一次访问cache，0一定会发生强制性失效，之后cache里块号为0的块不断地被替换写入替换写入，此时发生冲突失效。

则失效次数为20000，则失效率为：

20000/20000=1=100%

命中率为0。

失效类型为强制性失效次数1，冲突失效次数为19999。

2）2路组相联：

array[0]的块地址为0，映像到cache的组号为0：

0modulo8=0

array[132]的块地址为132/4=33，映像到cache组号为1：

33modulo8=1

命中次数为19998次，命中率为：

array[0]的块地址为0，映像到cache组号为：

array[131]的块地址为131/4=32，映像到cache组号为：

32modulo8=0

因为第一次访问cache，0和1一定会发生强制性失效，之后因为是2路组相联，array[0]与array[131]都在0组，不会发生失效，则失效次数为2，失效率为：

4、模拟器上实验结果检验

因为例题的循环次数为10000，为了便于实验，我将循环次数设置为100，结果参照100的计算，原理是一致的。

因为实际131/132都是字地址，而project.txt设置的是字节地址，所以将project.txt里值设置为0和132*4/131*4循环100次，设置cache大小为256，block大小为4，可以分别看到直接映射和2路组相连映射的结果为：

直接映射

stride=132

stride=131

misscount

　2

　200

missrate

　0.01

　1.00

hitcount

　198

　0

hitrate

　0.99

accesscount

c1c（强制性失效）

c2c（容量性失效）

c3c（冲突性失效）

2路组相连映射

可以看到实验结果与计算是一致的（因为循环次数100，所以实验结果小数点要后移两位）。

同时对习题1的思考（见后）也证明是正确的。

（1）直接映射：

stride=132截图

（2）直接映射：

stride=131截图

（3）2路组相连：

（4）2路组相连：

三、整体分析

1、三种映射方式对Cache效率的的影响

其他相同条件：

block大小为2，组相连相连度为4，project.txt为200个0~1000的随机数。

cache容量（字节）

映射方式

组相连

全相连

64

0.94

0.935

0.925

128

0.87

0.875

0.865

256

0.79

0.785

512

0.68

0.63

0.61

1024

0.50

生成图表：

此时可以看到：

1.直接映射的失效率高，组相连失效率中等，全相连失效率最低

2.随着cache容量的增加，失效率越小。

3.当cache容量为1024时，因为数据取值的原因，三种方式失效率相等，说明当cache容量足够大，三种方式失效率是一样的。

2、block块大小与Cache容量对Cache效率的影响

直接映射，相连度为1，project.txt为200个0~1000的随机数。

块大小（字）

Cache容量（字节）

1

0.885

0.83

0.77

0.69

2

4

0.95

0.905

0.80

0.635

0.30

8

0.945

0.89

0.575

0.155

生成图表：

1.对于给定的cache容量如64字节，当块大小增加时，失效率先是下降，后来反而上升了。

2.Cache容量越大，使其失效率达到最低的块的大小就越大。

3.因为取得数据样本是随机的，不是连续的，实验数据并不是十分准确，比如cache容量128时，块大小出现两次失效率

3、Cache容量与相连度对Cache效率的影响

组相连，块大小2，project.txt为200个0~1000的随机数。

相连度/路

0.93

0.915

0.86

0.765

0.78

0.645

0.64

0.67

0.66

0.535

1.提高相连度会使失效率下降。

2.因为取得数据样本是随机的，不是连续的，实验数据并不是十分准确。

3.当容量为1024时，也就是cache一定大时，失效率没什么区别。

4、三种失效类型影响因素

（1）相连度对三种失效类型影响：

cache大小为256，block大小为2，组相连，project.txt为200个0~1000的随机数。

相连度（路）

总失效率

总失效次数

失效类型

强制性失效

容量失效

冲突失效

156

107

38

11

160

40

13

153

41

5

157

45

16

46

可以看出：

1.强制性失效，即冷启动，不受相连度的影响。

2.容量失效基本不受相连度影响，但因为数据偶然性，出现增大趋势。

3.冲突失效随着相连度的增加而降低。

（2）Cache容量对三种失效类型影响：

block大小为2，组相连度为4，project.txt为200个0~1000的随机数。

失效类型（相对百分比）

186

78

174

65

可以看出：

1.容量越大，失效率越小。

2.强制性失效不受容量大小的影响。

3.容量失效随着容量的增加而大大减小。

4.冲突失效不受容量大小的影响。

四、实验思考和感受

1、关于模拟器的思考

Cache大小可选为16/64/128/256，因为代码写了，但是没有增加选项。

但是，我考虑因为16实在太小了，没什么意义。

打开文件名字为project.txt，修改文件名。

个人感觉有地方不太合适，因为直接映像就是特殊的组相联映射，所以相联度一定为1，但是代码中并没有设计这一点，当一个完全不懂得人使用时，很有可能设置相联度大于1，造成错误。

另外我觉得可以把三种方式各封装在一个自己的函数里，这样代码更加清晰。

有困惑我的问题，我是通过阅读代码才比较清晰的理解cache实现的，但是模拟器给出的地址映射的方法是将数据字节地址转换为字地址，又将字地址转换为块地址，对块地址进行取模运算。

而习题1是直接对字地址进行取模运算，方法明显不一致。

通过我重新阅读习题1的题目，发现实际习题1的132/131是字地址，因为定义的intarray[]数组定义的是整数字长，所以132/131指的是地址为字地址，例如两个地址之间是一个整数字长。

2、关于整个实验的思考

这次实验是我大学做的最用心的一次实验，没有之一。

我在仔细的阅读实验代码后，知道了内存的物理地址是怎样转换为cache的块号或组号的。

我根据自己的理解，画了一个模拟寻址图，更加清晰的知道原理，理顺清楚到底是怎么一回事，收获很大。

在做整体分析时，我采用图表折线图的方式，更加直观的看出数据的走势。

但是我最初的设想采样样本是像一条平滑的曲线一样，自动的生成一组相对连续的数据，但是我只会生成随机数。

而随机数是离散的，所以，以后有机会，我希望采用连续数据的样本，重新得出更加准确的结果。

总体来说，实验还是相对简单的，但是注重理解。

理论与实践结合起来，加深了我对cache部分学习的理解，同时，也锻炼了我自主思考，自主学习的能力。

比如，整体分析部分，采用不同变量结果比较方法等等。

希望在今后的学习当中，继续保持，继续进步。