这里看不懂的可以先看上一篇
FIFO：
就是先进先出
URL：
哪个块 ，上一次被用到的时间点最早 ，被替换掉
块 ， 每一次被用到的时候，都会更新一下时间点
Random：
随机 替换
模拟器正确性的验证：
模拟器实现的正确与否，可以通过读取trace文件，模拟cache运行，再得到输出。比如对于trace5.txt的模拟。
Trace5.txt:
w 10 1w 30 2
w 50 3
w 70 4
w 90 5
w 70 6
w 50 7
w 30 8
w 10 9
对于上述的三个存储访问记录，对于32大小的直接映射缓存而言，上述的三个地址都映射到同一个地址，因此会涉及到2次miss，1次hit。具体的数据如下：
数据取前6位 ， 组号 = 数据%8
10H = 00010000 => 数据 ： 4 ， 组号： 4
30H = 00110000 => 数据 ： 12 ，组号 ： 4
50H = 01010000 => 数据 ： 20 ，组号 ： 4
70H = 00110000 => 数据 ： 28 ，组号 ： 4
90H = 10010000 => 数据 ： 36 ，组号 ： 4
LRU的话 ， 这里刚好比较特殊 ， 和FIFO结果刚好一样 ，
但是一旦数据多了 ， 就会体会到其中的差别
代码：
Random:
#include
#include
#include
#include
#include
#include
using namespace std; #define _u32 unsigned int #define _u8 unsigned int int main() { string buffer; string str[3]; int count[32][4] = {0}, record[32][4] = {0};//用于记录是否使用过 用1 0 表示 int index1[32] = {0};//记录每个组有多少块已经有数据了 int records; int temp; //用于random算法中设置随机数 int index=0; //看这个是否是满的 int index2 = 0; //判断组中是否含有该数 ifstream in("trace5.txt"); if (! in.is_open()) { cout << "Error opening file"; exit (1); } _u32 cache_size = 32; _u32 cache_r_count = 0; /* 读cache次数 */ _u32 cache_w_count = 0; /* 写cache次数 */ _u32 cache_mem_read = 0; /*cache读mem次数；*/ _u32 cache_mem_write = 0; /*cache写mem次数;*/ _u32 cache_hit_count = 0; /*cache命中的次数*/ _u32 cache_miss_count = 0; /*cache缺失的次数*/ _u32 capacity_miss_count = 0; /* 容量缺失 */ _u32 conflict_miss_count = 0; /* 冲突缺失 */ _u32 cache_avaliable; cache_avaliable = cache_size;//缓存的容量赋值给总的可使用值 int sizecount = 0; while (!in.eof() ) { //cout << buffer << endl; getline空格也算一个字符 getline(in, buffer);/*要用#include
*/ int s = 0, i; istringstream stream(buffer); stream >> str[0] >> str[1] >> str[2]; //一个字符串一个字符串地取出 // 十六进制的字符串转化为十进制的数字 for (i = 0; i<2; i++) { if (str[1][i] >= 'a'&& str[1][i] <= 'f') { s = s * 16 + str[1][i] - 87; } else if (str[1][i] >= '0'&& str[1][i] <= '9') { s = s * 16 + str[1][i] - 48; } else if (str[1][i] >= 'A' && str[1][i] <= 'F') { s = s * 16 + str[1][i] - 55; } } s = s / 4; //除去无用的低两位 //cout << s << " ";//测试输出 //记录初始地址，要和后来的相同的余进行比较原值 records = s; if(buffer[0] == 'w') { cache_w_count++; //由于是4路组相连 ， 所以每个组有四个 ， 一共有8个组 ， 所以对8求余 if (s >= 8) //大于8时进行求余 { s = s % 8; } index = 0; temp = index1[s]; // 记录当前组的被占用块的个数 index2=0; //判断一下组里有没有和它一样的 //如果有一样的index2 = 1 ， 直接hit到了 for(i=0 ; i<4 ; i++){ if(record[s][i] == records) { index2 = 1; break; } } if(index2){ cache_hit_count++; } //如果组里没有的话 else{ //计数,random //组里面被占用的块的个数 <4 , 那么接着往里面存 //组内块满之前，不考虑替换策略，按顺序往下排 if (temp < 4){ count[s][temp] = 1; cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 conflict_miss_count++; //冲突记录 record[s][temp] = records; //将之前的s记录并用于之后的比较 if(cache_avaliable > 0) //如果缓存还有的话 { cache_avaliable--; } index1[s]++; } else //若有记录 { if (sizecount >= cache_size) //记录拿了多少内存 若超出即是内存冲突 { capacity_miss_count++; conflict_miss_count--; //要减去之前都加一的缺失冲突 } //超出缓存范围 else//如果没记录就说明是另外的地址 虽然重复但还是缺失 { cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 //如果该组中满了，其他组还可以用，那么久发生conflict_miss_count冲突 conflict_miss_count++; //随机找一个0~3之间的数，并将所对应快内的数据替换 temp = rand()%4; record[s][temp] = records; cache_mem_write++; } } } } //写！！！！ else if(buffer[0] == 'r') { cache_r_count++; if (s >= 8) //大于8时进行求余 { s = s % 8; } index = 0; temp = index1[s]; index2 = 0; for(i=0 ; i<4 ; i++) { if(record[s][i] == records) { index2 = 1; break; } } if(index2){ cache_hit_count++; }else{ //计数,random if (temp<4) //若没有记录 { count[s][temp] = 1; cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 conflict_miss_count++; //冲突记录 record[s][temp] = records; //将之前的s记录并用于之后的比较 if(cache_avaliable > 0) //如果缓存还有的话 { cache_avaliable--; } index1[s]++; } else //若有记录 { if (sizecount >= cache_size) //记录拿了多少内存 若超出即是内存冲突 { capacity_miss_count++; conflict_miss_count--; //要减去之前都加一的缺失冲突 } //超出缓存范围 else//如果没记录就说明是另外的地址 虽然重复但还是缺失 { cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 //如果该组中满了，其他组还可以用，那么久发生conflict_miss_count冲突 for(i=0 ; i<4 ; i++) { if(count[s][i] == 0) { index = 1; break; } } if(!index) conflict_miss_count++; temp = rand()%4; record[s][temp] = records; //cache_mem_write++; } } } } } cout << "cache_r_count =" << cache_r_count << "," << "cache_w_count =" << cache_w_count<< endl; cout << "cache_mem_read =" << cache_mem_read << "," << "cache_mem_write =" << cache_mem_write << endl; cout << "cache_hit_count =" << cache_hit_count << "," << "cache_miss_count =" << cache_miss_count << endl; cout << "capacity_miss_count =" << capacity_miss_count << "," << "conflict_miss_count =" << conflict_miss_count << endl; cout << "cache_avaliable_size =" << cache_avaliable << endl; // cout << sizecount; return 0; }
FIFO:
#include
#include
#include
#include
#include
#include
using namespace std; #define _u32 unsigned int #define _u8 unsigned int int main() { string buffer; string str[3]; int count[32][4] = {0}, record[32][4] = {0};//用于记录是否使用过 用1 0 表示 int index1[32] = {0}; int records; int temp; //用于random算法中设置随机数 int index=0; //看这个是否是满的 int index2 = 0; //判断组中是否含有该数 ifstream in("trace6.txt"); if (! in.is_open()) { cout << "Error opening file"; exit (1); } _u32 cache_size = 32; _u32 cache_r_count = 0; /* 读cache次数 */ _u32 cache_w_count = 0; /* 写cache次数 */ _u32 cache_mem_read = 0; /*cache读mem次数；*/ _u32 cache_mem_write = 0; /*cache写mem次数;*/ _u32 cache_hit_count = 0; /*cache命中的次数*/ _u32 cache_miss_count = 0; /*cache缺失的次数*/ _u32 capacity_miss_count = 0; /* 容量缺失 */ _u32 conflict_miss_count = 0; /* 冲突缺失 */ _u32 cache_avaliable; cache_avaliable = cache_size;//缓存的容量赋值给总的可使用值 int sizecount = 0; while (!in.eof() ) { //cout << buffer << endl; getline空格也算一个字符 getline(in, buffer);/*要用#include
*/ int s = 0, i; istringstream stream(buffer); stream >> str[0] >> str[1] >> str[2]; //一个字符串一个字符串地取出 // 十六进制的字符串转化为十进制的数字 for (i = 0; i<2; i++) { if (str[1][i] >= 'a'&& str[1][i] <= 'f') { s = s * 16 + str[1][i] - 87; } else if (str[1][i] >= '0'&& str[1][i] <= '9') { s = s * 16 + str[1][i] - 48; } else if (str[1][i] >= 'A' && str[1][i] <= 'F') { s = s * 16 + str[1][i] - 55; } } s = s / 4; //除去无用的低两位 //记录初始地址，要和后来的相同的余进行比较原值 records = s; //读！！！！！ if(buffer[0] == 'w') { cache_w_count++; if (s >= 8) //大于8时进行求余 { s = s % 8; } index = 0; temp = index1[s]; index2=0; for(i=0 ; i<4 ; i++) { if(record[s][i] == records) { index2 = 1; break; } } if(index2){ cache_hit_count++; }else{ //计数,random if (count[s][temp] == 0) //若没有记录 { count[s][temp] = 1; cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 conflict_miss_count++; //冲突记录 record[s][temp] = records; //将之前的s记录并用于之后的比较 if(cache_avaliable > 0) //如果缓存还有的话 { cache_avaliable--; } index1[s]++; index1[s] = index1[s]%4; } else //若有记录 { if (sizecount >= cache_size) //记录拿了多少内存 若超出即是内存冲突 { capacity_miss_count++; conflict_miss_count--; //要减去之前都加一的缺失冲突 } //超出缓存范围 else//如果没记录就说明是另外的地址 虽然重复但还是缺失 { cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 //如果该组中满了，其他组还可以用，那么久发生conflict_miss_count冲突 for(i=0 ; i<4 ; i++) { if(count[s][i] == 0) { index = 1; break; } } if(!index) conflict_miss_count++; record[s][temp] = records; cache_mem_write++; index1[s]++; index1[s] = index1[s]%4; } } } } //写！！！！ else if(buffer[0] == 'r') { cache_r_count++; if (s >= 8) //大于8时进行求余 { s = s % 8; } index = 0; temp = index1[s]; index2 = 0; for(i=0 ; i<4 ; i++) { if(record[s][i] == records) { index2 = 1; break; } } if(index2){ cache_hit_count++; }else{ //计数,random if (count[s][temp] == 0) //若没有记录 { count[s][temp] = 1; cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 conflict_miss_count++; //冲突记录 record[s][temp] = records; //将之前的s记录并用于之后的比较 if(cache_avaliable > 0) //如果缓存还有的话 { cache_avaliable--; } index1[s]++; index1[s] = index1[s]%4; } else //若有记录 { if (sizecount >= cache_size) //记录拿了多少内存 若超出即是内存冲突 { capacity_miss_count++; conflict_miss_count--; //要减去之前都加一的缺失冲突 } //超出缓存范围 else//如果没记录就说明是另外的地址 虽然重复但还是缺失 { cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 //如果该组中满了，其他组还可以用，那么久发生conflict_miss_count冲突 for(i=0 ; i<4 ; i++) { if(count[s][i] == 0) { index = 1; break; } } if(!index) conflict_miss_count++; record[s][temp] = records; //cache_mem_write++; index1[s]++; index1[s] = index1[s]%4; } } } } } cout << "cache_r_count =" << cache_r_count << "," << "cache_w_count =" << cache_w_count<< endl; cout << "cache_mem_read =" << cache_mem_read << "," << "cache_mem_write =" << cache_mem_write << endl; cout << "cache_hit_count =" << cache_hit_count << "," << "cache_miss_count =" << cache_miss_count << endl; cout << "capacity_miss_count =" << capacity_miss_count << "," << "conflict_miss_count =" << conflict_miss_count << endl; cout << "cache_avaliable_size =" << cache_avaliable << endl; // cout << sizecount; return 0; }
LRU:
#include
#include
#include
#include
#include
#include
using namespace std; #define _u32 unsigned int #define _u8 unsigned int int main() { string buffer; string str[3]; int count[32][4] = {0}, record[32][4] = {0};//用于记录是否使用过 用1 0 表示 int time[32][4] = {0}; int index1[32] = {0}; int records; int temp; //用于random算法中设置随机数 int index=0; //看这个是否是满的 int index2 = 0; //判断组中是否含有该数 int TimeSum = 0; int ways = 0; cout << "请问你要用哪种方式：1.FIFO替换策略 2.LRU替换策略" <
> ways; ifstream in("trace1.txt"); if (! in.is_open()) { cout << "Error opening file"; exit (1); } _u32 cache_size = 32; _u32 cache_r_count = 0; /* 读cache次数 */ _u32 cache_w_count = 0; /* 写cache次数 */ _u32 cache_mem_read = 0; /*cache读mem次数；*/ _u32 cache_mem_write = 0; /*cache写mem次数;*/ _u32 cache_hit_count = 0; /*cache命中的次数*/ _u32 cache_miss_count = 0; /*cache缺失的次数*/ _u32 capacity_miss_count = 0; /* 容量缺失 */ _u32 conflict_miss_count = 0; /* 冲突缺失 */ _u32 cache_avaliable; cache_avaliable = cache_size;//缓存的容量赋值给总的可使用值 int sizecount = 0; while (!in.eof() ) { //cout << buffer << endl; getline空格也算一个字符 getline(in, buffer);/*要用#include
*/ int s = 0, i; istringstream stream(buffer); stream >> str[0] >> str[1] >> str[2]; //一个字符串一个字符串地取出 // 十六进制的字符串转化为十进制的数字 for (i = 0; i<2; i++) { if (str[1][i] >= 'a'&& str[1][i] <= 'f') { s = s * 16 + str[1][i] - 87; } else if (str[1][i] >= '0'&& str[1][i] <= '9') { s = s * 16 + str[1][i] - 48; } else if (str[1][i] >= 'A' && str[1][i] <= 'F') { s = s * 16 + str[1][i] - 55; } } s = s / 4; //除去无用的低两位 //记录初始地址，要和后来的相同的余进行比较原值 records = s; if(ways == 2){ //读！！！！！ if(buffer[0] == 'w') { cache_w_count++; if (s >= 8) //大于8时进行求余 { s = s % 8; } index = 0; temp = index1[s]; index2=0; for(i=0 ; i<4 ; i++) { if(record[s][i] == records) { index2 = 1; break; } } if(index2) { cache_hit_count++; time[s][i] = TimeSum; TimeSum++; //cout << '2' << time[s][i] << record[s][i]<< endl; } else { if (record[s][temp] == 0) //若没有记录 { count[s][temp] = 1; cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 conflict_miss_count++; //冲突记录 record[s][temp] = records; //将之前的s记录并用于之后的比较 if(cache_avaliable > 0) //如果缓存还有的话 { cache_avaliable--; } index1[s]++; index1[s] = index1[s]%4; time[s][temp] = TimeSum; TimeSum++; } else //若有记录 { //找到用的次数最少的那个数据 temp = 0; for(i=0 ; i<4 ; i++) { if(time[s][temp]>time[s][i]){ temp = i; } } //cout << temp << endl; if (sizecount >= cache_size) //记录拿了多少内存 若超出即是内存冲突 { capacity_miss_count++; conflict_miss_count--; //要减去之前都加一的缺失冲突 } //超出缓存范围 else//如果没记录就说明是另外的地址 虽然重复但还是缺失 { cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 //如果该组中满了，其他组还可以用，那么久发生conflict_miss_count冲突 for(i=0 ; i<4 ; i++) { if(count[s][i] == 0) { index = 1; break; } } if(!index) conflict_miss_count++; record[s][temp] = records; cache_mem_write++; time[s][temp] = TimeSum; TimeSum++; } } } } //写！！！！ else if(buffer[0] == 'r') { cache_r_count++; if (s >= 8) //大于8时进行求余 { s = s % 8; } index = 0; index2 = 0; for(i=0 ; i<4 ; i++) { if(record[s][i] == records) { index2 = 1; time[s][i] = TimeSum; TimeSum++; break; } } if(index2) { cache_hit_count++; } else { //计数,random if (count[s][temp] == 0) //若没有记录 { count[s][temp] = 1; cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 conflict_miss_count++; //冲突记录 record[s][temp] = records; //将之前的s记录并用于之后的比较 if(cache_avaliable > 0) //如果缓存还有的话 { cache_avaliable--; } index1[s]++; index1[s] = index1[s]%4; } else //若有记录 { //找到用的次数最少的那个数据 temp = 0; for(i=0 ; i<4 ; i++) { if(time[s][temp]>time[s][i]){ temp = i; } } if (sizecount >= cache_size) //记录拿了多少内存 若超出即是内存冲突 { capacity_miss_count++; conflict_miss_count--; //要减去之前都加一的缺失冲突 } //超出缓存范围 else//如果没记录就说明是另外的地址 虽然重复但还是缺失 { cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 //如果该组中满了，其他组还可以用，那么久发生conflict_miss_count冲突 for(i=0 ; i<4 ; i++) { if(count[s][i] == 0) { index = 1; break; } } if(!index) conflict_miss_count++; record[s][temp] = records; } } index1[s]++; index1[s] = index1[s]%4; time[s][i] = TimeSum; TimeSum++; } } } else if(ways == 1) { //读！！！！！ if(buffer[0] == 'w') { cache_w_count++; if (s >= 8) //大于8时进行求余 { s = s % 8; } index = 0; temp = index1[s]; index2=0; for(i=0 ; i<4 ; i++) { if(record[s][i] == records) { index2 = 1; break; } } if(index2) { cache_hit_count++; } else { //计数,random if (count[s][temp] == 0) //若没有记录 { count[s][temp] = 1; cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 conflict_miss_count++; //冲突记录 record[s][temp] = records; //将之前的s记录并用于之后的比较 if(cache_avaliable > 0) //如果缓存还有的话 { cache_avaliable--; } index1[s]++; index1[s] = index1[s]%4; } else //若有记录 { if (sizecount >= cache_size) //记录拿了多少内存 若超出即是内存冲突 { capacity_miss_count++; conflict_miss_count--; //要减去之前都加一的缺失冲突 } //超出缓存范围 else//如果没记录就说明是另外的地址 虽然重复但还是缺失 { cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 //如果该组中满了，其他组还可以用，那么久发生conflict_miss_count冲突 for(i=0 ; i<4 ; i++) { if(count[s][i] == 0) { index = 1; break; } } if(!index) conflict_miss_count++; record[s][temp] = records; cache_mem_write++; index1[s]++; index1[s] = index1[s]%4; } } } } //写！！！！ else if(buffer[0] == 'r') { cache_r_count++; if (s >= 8) //大于8时进行求余 { s = s % 8; } index = 0; temp = index1[s]; index2 = 0; for(i=0 ; i<4 ; i++) { if(record[s][i] == records) { index2 = 1; break; } } if(index2) { cache_hit_count++; } else { //计数,random if (count[s][temp] == 0) //若没有记录 { count[s][temp] = 1; cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 conflict_miss_count++; //冲突记录 record[s][temp] = records; //将之前的s记录并用于之后的比较 if(cache_avaliable > 0) //如果缓存还有的话 { cache_avaliable--; } index1[s]++; index1[s] = index1[s]%4; } else //若有记录 { if (sizecount >= cache_size) //记录拿了多少内存 若超出即是内存冲突 { capacity_miss_count++; conflict_miss_count--; //要减去之前都加一的缺失冲突 } //超出缓存范围 else//如果没记录就说明是另外的地址 虽然重复但还是缺失 { cache_miss_count++; cache_mem_read++;//不管是读还是写，没有都要去读取的 sizecount++; //记录容量的分配和使用 //如果该组中满了，其他组还可以用，那么久发生conflict_miss_count冲突 for(i=0 ; i<4 ; i++) { if(count[s][i] == 0) { index = 1; break; } } if(!index) conflict_miss_count++; record[s][temp] = records; //cache_mem_write++; index1[s]++; index1[s] = index1[s]%4; } } } } } } cout << "cache_r_count =" << cache_r_count << "," << "cache_w_count =" << cache_w_count<< endl; cout << "cache_mem_read =" << cache_mem_read << "," << "cache_mem_write =" << cache_mem_write << endl; cout << "cache_hit_count =" << cache_hit_count << "," << "cache_miss_count =" << cache_miss_count << endl; cout << "capacity_miss_count =" << capacity_miss_count << "," << "conflict_miss_count =" << conflict_miss_count << endl; cout << "cache_avaliable_size =" << cache_avaliable << endl; // cout << sizecount; return 0; }
1187
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
