/* 根据LFU算法进行页面替换 */
void do_LFU(Ptr_PageTableItem ptr_pageTabIt)
{
unsigned int i, min, page;
printf("没有空闲物理块，开始进行LFU页面替换...\n");
for (i = 0, min = 0xFFFFFFFF, page = 0; i < PAGE_SUM; i++)
{
if (pageTable[i].count < min)
{
min = pageTable[i].count;
page = i;
}
}
printf("选择第%u页进行替换\n", page);
if (pageTable[page].edited)
{
/* 页面内容有修改，需要写回至辅存 */
printf("该页内容有修改，写回至辅存\n");
do_page_out(&pageTable[page]);
}
pageTable[page].filled = FALSE;
pageTable[page].count = 0;
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, pageTable[page].blockNum);
/* 更新页表内容 */
ptr_pageTabIt->blockNum = pageTable[page].blockNum;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->count = 0;
printf("页面替换成功\n");
}
/* 处理缺页中断 */
void do_page_fault(Ptr_PageTableItem ptr_pageTabIt)
{
unsigned int i;
printf("产生缺页中断，开始进行调页...\n");
for (i = 0; i < BLOCK_SUM; i++)
{
if (!blockStatus[i])
{
//printf("this is a test");
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, i);
//printf("this is a test");
/* 更新页表内容 */
ptr_pageTabIt->blockNum = i;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->count = 0;
ptr_pageTabIt->time = cpuTime;
blockStatus[i] = TRUE;
return;
}
}
/* 没有空闲物理块，进行页面替换 */
do_LFU(ptr_pageTabIt);
}
void do_switch(Ptr_PageTableItem ptr_pageTabIt)
{
unsigned int rec = 0, i;
unsigned char min = 255;
printf("没有空闲物理块，开始进行老化页面替换...\n");
for (i = 0; i < PAGE_SUM; i++)
{
if (pageTable[i].filled && pageTable[i].count < min){
min = pageTable[i].count;
rec = i;
}
}
printf("选择第%u页进行替换\n", rec);
if (pageTable[rec].edited)
{
/* 页面内容有修改，需要写回至辅存 */
printf("该页内容有修改，写回至辅存\n");
do_page_out(pageTable + rec);
}
pageTable[rec].filled = FALSE;
pageTable[rec].count = 0;
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, pageTable[rec].blockNum);
/* 更新页表内容 */
ptr_pageTabIt->blockNum = pageTable[rec].blockNum;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
printf("页面替换成功\n");
}
/* 根据LFU算法进行页面替换 */
void do_LFU(Ptr_PageTableItem ptr_pageTabIt)
{
unsigned int i, min, page;
printf("没有空闲物理块，开始进行LFU页面替换...\n");
/*for (i = 0, min = 0xFFFFFFFF, page = 0; i < BLOCK_SUM; i++)
{
if (actualMemory[i]->count < min)
{
min = actualMemory[i]->count;
page = i;
}
}*/
page=clear();
printf("选择第%u页进行替换\n", page);
if (actualMemory[i]->edited)
{
/* 页面内容有修改，需要写回至辅存 */
printf("该页内容有修改，写回至辅存\n");
do_page_out(actualMemory[page]);
}
actualMemory[i]->filled = FALSE;
actualMemory[i]->count = 0;
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt,page);
/* 更新页表内容 */
ptr_pageTabIt->blockNum=page;
ptr_pageTabIt->filled=TRUE;
ptr_pageTabIt->edited=FALSE;
ptr_pageTabIt->count=0;
blockStatus[page]=TRUE;
printf("页面替换成功\n");
}
void do_LRU(Ptr_PageTableItem ptr_pageTabIt)//LRU算法
{
unsigned int i, page;
int max;
printf("没有空闲物理块，开始进行LRU页面替换...\n");
for (i = 0, max=-1, page = 0; i < PAGE_SUM; i++)
{
if (pageTable[i].filled&&pageTable[i].count_LRU > max)
{
max= pageTable[i].count_LRU;
page = i;
}//选择计数值最大的页面替换
}
printf("选择第%u页进行替换\n", page);
if (pageTable[page].edited)
{
/* 页面内容有修改，需要写回至辅存 */
printf("该页内容有修改，写回至辅存\n");
do_page_out(&pageTable[page]);
}
pageTable[page].filled = FALSE;
pageTable[page].count = 0;
pageTable[page].count_1=0;
pageTable[page].count_LRU=0;
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, pageTable[page].blockNum);//
/* 更新页表内容 */
ptr_pageTabIt->blockNum = pageTable[page].blockNum;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->count_LRU= 0;//
printf("页面替换成功\n");
}
/* 处理缺页中断 */
void do_page_fault(Ptr_PageTableItem ptr_pageTabIt)
{
unsigned int i;
printf("产生缺页中断，开始进行调页...\n");
for (i = 0; i < PAGE_SUM; i++)
{
pageTable[i].count /= 2;
if (pageTable + i == ptr_pageTabIt)
{
pageTable[i].count += 128;
}
}
for (i = 0; i < BLOCK_SUM; i++)
{
if (!blockStatus[i])
{
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, i);
/* 更新页表内容 */
ptr_pageTabIt->blockNum = i;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
blockStatus[i] = TRUE;
return;
}
}
/* 没有空闲物理块，进行页面替换 */
do_switch(ptr_pageTabIt);
}
/////jm
void do_OldPage(Ptr_PageTableItem ptr_pageTabIt)//页面老化算法
{
unsigned int i, min, page;
printf("没有空闲物理块，开始进行页面老化替换...\n");
for (i = 0, min = 0xFFFFFFFF, page = 0; i < PAGE_SUM; i++)
{
if (pageTable[i].filled&&pageTable[i].count_1<min)//修改源码中的bug
{
min = pageTable[i].count_1;
page = i;
}//选择计数值最小的页面替换
}
printf("选择第%u页进行替换\n", page);
if (pageTable[page].edited)
{
/* 页面内容有修改，需要写回至辅存 */
printf("该页内容有修改，写回至辅存\n");
do_page_out(&pageTable[page]);
}
pageTable[page].filled = FALSE;
pageTable[page].count = 0;
pageTable[page].count_1=0;
pageTable[page].R=0;
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, pageTable[page].blockNum);
/* 更新页表内容 */
ptr_pageTabIt->blockNum = pageTable[page].blockNum;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->count = 0;
ptr_pageTabIt->count_1=0;
ptr_pageTabIt->R=1;
printf("页面替换成功\n");
}
/* 处理缺页中断 */
void do_page_fault(Ptr_PageTableItem ptr_pageTabIt)
{
unsigned int i;
printf("产生缺页中断，开始进行调页...\n");
//先找没有写进页表中的物理块,没有的话进行调度
for (i = 0; i < BLOCK_SUM; i++)
{
if (!blockStatus[i])
{
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, i);
/* 更新页表内容 */
ptr_pageTabIt->blockNum = i;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->count = 0;
ptr_pageTabIt->LRU_flag = 1;
blockStatus[i] = TRUE;
return;
}
}
/* 没有空闲物理块，进行页面替换 */
//do_LFU(ptr_pageTabIt);
//do_LRU(ptr_pageTabIt);
do_LRU_aging(ptr_pageTabIt);
}
/* 处理缺页中断 */
void do_page_fault(Ptr_PageTableItem ptr_pageTabIt)
{
unsigned int i, c;
printf("产生缺页中断，开始进行调页...\n");
for (i = 0; i < BLOCK_SUM; i++)
{
if (!blockStatus[i])
{
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, i);
/* 更新页表内容 */
ptr_pageTabIt->blockNum = i;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->visited = 0;
for(c = 0;c < 8;c++){
ptr_pageTabIt->count[c] = '0';
}
blockStatus[i] = TRUE;
return;
}
}
/* 没有空闲物理块，进行页面替换 */
do_PA(ptr_pageTabIt);
}
/* 处理缺页中断 */
void do_page_fault(Ptr_PageTableItem ptr_pageTabIt)
{
unsigned int i;
printf("产生缺页中断，开始进行调页...\n");
for (i = 0; i < BLOCK_SUM; i++)
{
if (!blockStatus[i])
{
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, i);
/* 更新页表内容 */
ptr_pageTabIt->blockNum = i;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->count = 0;
// ptr_pageTabIt->progressNum=ptr_memAccReq->FromProgress;
blockStatus[i] = TRUE;
return;
}
}
/* 没有空闲物理块，进行页面替换 */
do_LRU(ptr_pageTabIt);
}
void JGdo_page_catalogue_fault(Ptr_PageCatalogueItem ptr_pageCatalogueItem)
{
unsigned int i, j, virAddr;
PageTableItem pageTabItem;
printf("产生缺页目录中断，开始进行调页...\n");
for (i = 0; i < BLOCK_SUM; i++)
{
if (!blockStatus[i])
{
pageTabItem.auxAddr = ptr_pageCatalogueItem->auxAddr;
/* 读辅存内容，写入到实存 */
do_page_in(&pageTabItem, i);
/* 更新页目录和页表内容 */
virAddr = ptr_memAccReq->virAddr;
for (j = 0; j < PAGE_CATALOGUE_SUM; j++)
if (!pageStatus[j])
break;
ptr_pageCatalogueItem->pageNum = j;
pageStatus[j] = TRUE;
pageTable[j * PAGE_SIZE + JGcalPageCatalogueOffset()].blockNum = i;
pageTable[j * PAGE_SIZE + JGcalPageCatalogueOffset()].filled = TRUE;
pageTable[j * PAGE_SIZE + JGcalPageCatalogueOffset()].edited = FALSE;
pageTable[j * PAGE_SIZE + JGcalPageCatalogueOffset()].count = 0;
blockStatus[i] = TRUE;
return;
}
}
/* 没有空闲物理块，进行页面替换 */
JGunknown();
}
/* 根据页面老化算法进行页面替换 */
void do_PA(Ptr_PageTableItem ptr_pageTabIt)
{
unsigned int i,k,s, min, page,index,processNum, c, temp_count;
printf("没有空闲物理块，开始进行页面老化算法页面替换...\n");
for(s=0,min=0xFFFFFFFF,page=0,index=0,processNum=0;s<Process_SUM;s++)
for(k=0;k<INDEX_SUM;k++)
for (i = 0; i < INDEX_PAGE; i++)
{
for(c = 0, temp_count = 0;c < 8;c++){
temp_count = temp_count * 10 + pageIndex[s][k].index[i].count[c] - '0';
}
if (temp_count < min && pageIndex[s][k].index[i].filled==TRUE)
{
min = temp_count;
processNum=s;
page = i;
index=k;
}
}
printf("选择第%u个目录第%u页进行替换\n",index,page);
if (pageIndex[processNum][index].index[page].edited)
{
/* 页面内容有修改，需要写回至辅存 */
printf("该页内容有修改，写回至辅存\n");
do_page_out(&pageIndex[processNum][index].index[page]);
}
pageIndex[processNum][index].index[page].filled = FALSE;
pageIndex[processNum][index].index[page].visited = 0;
for(c = 0;c < 8;c++){
pageIndex[processNum][index].index[page].count[c] = '0';
}
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt,pageIndex[processNum][index].index[page].blockNum);
/* 更新页表内容 */
ptr_pageTabIt->blockNum =pageIndex[processNum][index].index[page].blockNum;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->visited = 0;
for(c = 0;c < 8;c++){
ptr_pageTabIt->count[c] = '0';
}
printf("页面替换成功\n");
}
void do_LRU (Ptr_PageTableItem ptr_pageTabIt){
unsigned int i,page,popagenum;
unsigned int popage[PAGE_SUM];
printf("没有空闲物理块，开始进行LRU页面替换...\n");
for (i = 0,page = 0,popagenum=0; i < PAGE_SUM ; i++){
if (pageTable[i].filled && pageTable[i].LRU_flag ==0){
popage[popagenum++] = i;
}
}
if(popagenum>0){
page = popage[random()%popagenum] ;
}
else if (popagenum==0){ //没有找到未被使用的,随机选择一个
for (i = 0; i < PAGE_SUM; i++){
if (pageTable[i].filled){
popage[popagenum++] = i;
}
}
page = popage[random()%popagenum];
}
//随机选择一个
printf("选择第%u页进行替换\n", page);
//该页面对应的物理块修改了
if (pageTable[page].edited)
{
/* 页面内容有修改，需要写回至辅存 */
printf("该页内容有修改，写回至辅存\n");
do_page_out(&pageTable[page]);
}
pageTable[page].filled = FALSE;
pageTable[page].LRU_flag = 0;
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, pageTable[page].blockNum);
/* 更新页表内容 */
ptr_pageTabIt->blockNum = pageTable[page].blockNum;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->LRU_flag = 0;
printf("页面替换成功\n");
}
//和LFU差不多，就是判断条件变了；怎么知道什么是最早最久使用的呢，建立一个链表，一旦使用了哪个
void do_LRU(Ptr_PageTableItem ptr_pageTabIt){
unsigned int i,j, pagei = 0,pagej = 0,blockNum;
int flag = 0;
printf("没有空闲物理块，开始进行LRU页面替换...\n");
while(flag==0){
//如果一直没有找到，说明当前的第一个已经被挪走了，再取一个；
blockNum = LRU_get();
for (i = 0; i < ROOT_PAGE_SUM; i++)
{
for(j = 0; j<CHILD_PAGE_SUM; j++)
{
if (pageTable[i][j].blockNum==blockNum && pageTable[i][j].filled==TRUE)
//在所有的被装入的页表中查找呦；谁最久没有被使用过了；找到在物理内存中的并且最早最久没被使用过的；
{
flag = 1;
pagei = i;
pagej = j;
//如何跳出两个循环?设置一个标示位；
break;
}
if(flag==1)
break;
}
}
}
printf("选择第%u页目录进行替换，选择选择第%u页号进行替换\n", pagei,pagej);
if (pageTable[pagei][pagej].edited)//被改写过了
{
/* 页面内容有修改，需要写回至辅存 */
printf("该页的内容有修改，写回至辅存\n");
do_page_out(&pageTable[pagei][pagej]);
}
pageTable[pagei][pagej].filled = FALSE;//没有被装入；
pageTable[pagei][pagej].count = 0;
/* 将辅存内容写入实存 */
do_page_in(ptr_pageTabIt, pageTable[pagei][pagej].blockNum);//这个位置的被取代了；
/* 更新页表内容 */
ptr_pageTabIt->blockNum = pageTable[pagei][pagej].blockNum;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->count = 0;
LRU_ChangeAdd(blockNum);
printf("页面替换成功\n");
}
/* 根据LFU算法进行页面替换 */
void do_LFU(Ptr_PageTableItem ptr_pageTabIt)
{
unsigned int i, j, k,min, firstpage, page;
int whichprogress=0;
printf("没有空闲物理块，开始进行LFU页面替换...\n");
for(k=0;k<VIRTUAL_PROGRESSES;k++)
for (i = 0, min = 0xFFFFFFFF, firstpage = 0, page = 0; i < LV1_PAGE_SUM; i++)
{
for (j = 0; j < LV2_PAGE_SUM; j++)
{
if (pageTable[k][i][j].count < min)
{
whichprogress=k;
min = pageTable[k][i][j].count;
firstpage = i;
page = j;
}
}
}
printf("选择第%u页进行替换\n", firstpage * LV1_PAGE_SUM + page);
if (pageTable[whichprogress][firstpage][page].edited)
{
/* 页面内容有修改，需要写回至辅存 */
printf("该页内容有修改，写回至辅存\n");
do_page_out(&pageTable[whichprogress][firstpage][page]);
}
pageTable[whichprogress][firstpage][page].filled = FALSE;
pageTable[whichprogress][firstpage][page].count = 0;
for(i=0;i<8;i++)
{
actmemcount[whichprogress][firstpage * LV1_PAGE_SUM + page][i]=0;
}
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, pageTable[whichprogress][firstpage][page].blockNum);
/* 更新页表内容 */
ptr_pageTabIt->blockNum = pageTable[whichprogress][firstpage][page].blockNum;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->count = 0;
printf("页面替换成功\n");
}
//修改了，
void do_LFU(Ptr_PageTableItem ptr_pageTabIt)
{
unsigned int i,j, min = 0xFFFFFFFF, pagei = 0,pagej = 0;
printf("没有空闲物理块，开始进行LRU页面替换...\n");
for (i = 0, min = 0xFFFFFFFF; i < ROOT_PAGE_SUM; i++)
{
for(j = 0; j<CHILD_PAGE_SUM; j++)
{
if (pageTable[i][j].count < min&&pageTable[i][j].filled==TRUE)//在所有的被装入的页表中查找呦；
{
min = pageTable[i][j].count;
pagei = i;
pagej = j;
}
}
}
printf("选择第%u页目录进行替换，选择选择第%u页号进行替换\n", pagei,pagej);
if (pageTable[pagei][pagej].edited)//被改写过了
{
/* 页面内容有修改，需要写回至辅存 */
printf("该页的内容有修改，写回至辅存\n");
do_page_out(&pageTable[pagei][pagej]);
}
pageTable[pagei][pagej].filled = FALSE;//没有被装入；
pageTable[pagei][pagej].count = 0;
/* 将辅存内容写入实存 */
do_page_in(ptr_pageTabIt, pageTable[pagei][pagej].blockNum);//这个位置的被取代了；
/* 更新页表内容 */
ptr_pageTabIt->blockNum = pageTable[pagei][pagej].blockNum;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->count = 0;
printf("页面替换成功\n");
}
/* 根据LFU算法进行页面替换 */
void do_LFU(Ptr_PageTableItem ptr_pageTabIt)
{
unsigned int i,k, min, page2 ,page1;
printf("没有空闲物理块，开始进行LFU页面替换...\n");
for (k = 0, min = 0xFFFFFFFF, page1 = 0,page2 = 0; k < PAGE_SUM2; k++)
{
for(i = 0;i< PAGE_SUM1; i++){
if (pageTable[k][i].count < min&&pageTable[k][i].filled) //修改4：加上filled的判断
{
min = pageTable[k][i].count;
page1 = i;
page2 = k;
}
}
}
printf("选择第%u页中的第%u页进行替换\n", page2 , page1 );
if (pageTable[page2][page1].edited)
{
/* 页面内容有修改，需要写回至辅存 */
printf("该页内容有修改，写回至辅存\n");
do_page_out(&pageTable[page2][page1]);
}
pageTable[page2][page1].filled = FALSE;
pageTable[page2][page1].count = 0;
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, pageTable[page2][page1].blockNum);
/* 更新页表内容 */
ptr_pageTabIt->blockNum = pageTable[page2][page1].blockNum;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->count = 0;
printf("页面替换成功\n");
}
void do_LRU(Ptr_PageTableItem ptr_pageTabIt)
{
unsigned int i,j,k,min,page,firstpage;
int flag=0;
int count[VIRTUAL_PROGRESSES][PAGE_SUM]={0};
int Whichprogress=0;
for(k=0;k<VIRTUAL_PROGRESSES;k++)
for(i=0;i<PAGE_SUM;i++)
{
for(j=0;j<8;j++)
count[k][i]=count[k][i]*2+actmemcount[k][i][j];
//printf("%d\n",count[i]);
}
printf("没有空闲物理块，开始进行LRU页面替换...\n");
for(k=0;k<VIRTUAL_PROGRESSES;k++)
for (i = 0, firstpage = 0, page = 0; i < LV1_PAGE_SUM; i++)
{
for (j = 0; j < LV2_PAGE_SUM; j++)
{
if (pageTable[k][i][j].filled)
{
Whichprogress=k;
firstpage = i;
page = j;
flag=1;
}
break;
}
if(flag==1)
{
break;
}
}
for(k=0;k<VIRTUAL_PROGRESSES;k++)
for (i = 0, min = 0xFFFFFFFF; i < LV1_PAGE_SUM; i++)
{
for (j = 0; j < LV2_PAGE_SUM; j++)
{
if (count[k][i*LV1_PAGE_SUM+j] < min
&&pageTable[k][i][j].filled)
{
Whichprogress=k;
min = count[k][i*LV1_PAGE_SUM+j];
firstpage = i;
page = j;
}
}
}
printf("选择第%u个进程页表的第%u页进行替换\n", k, firstpage * LV1_PAGE_SUM + page);
if (pageTable[Whichprogress][firstpage][page].edited)
{
/* 页面内容有修改，需要写回至辅存 */
printf("该页内容有修改，写回至辅存\n");
do_page_out(&pageTable[Whichprogress][firstpage][page]);
}
for(i=0;i<8;i++)
{
actmemcount[Whichprogress][firstpage * LV1_PAGE_SUM + page][i]=0;
}
whichprogress[pageTable[Whichprogress][firstpage][page].blockNum]=ptr_memAccReq->FromProgress;
pageTable[Whichprogress][firstpage][page].filled = FALSE;
pageTable[Whichprogress][firstpage][page].count = 0;
pageTable[Whichprogress][firstpage][page].blockNum = 0;
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, pageTable[Whichprogress][firstpage][page].blockNum);
/* 更新页表内容 */
ptr_pageTabIt->blockNum = pageTable[Whichprogress][firstpage][page].blockNum;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->count = 0;
//ptr_pageTabIt->progressNum=ptr_memAccReq->FromProgress;
printf("页面替换成功\n");
}
/* 初始化环境 */
void do_init()
{
int i, j,k,r,q,processCount,c;
srandom(time(NULL));
for(processCount=0;processCount<Process_SUM;processCount++)
for (k = 0; k < INDEX_SUM; k++)
for(i=0;i<INDEX_PAGE;i++)
{
pageIndex[processCount][k].processNum=processCount;
pageIndex[processCount][k].indexNum=k;
pageIndex[processCount][k].index[i].pageNum = i;
pageIndex[processCount][k].index[i].filled = FALSE;
pageIndex[processCount][k].index[i].edited = FALSE;
pageIndex[processCount][k].index[i].visited = 0;
for(c = 0;c < 8;c++){
pageIndex[processCount][k].index[i].count[c] = '0';
}
/* 使用随机数设置该页的保护类型 */
switch (random() % 7)
{
case 0:
{
pageIndex[processCount][k].index[i].proType = READABLE;
//pageTable[i].proType = READABLE;
break;
}
case 1:
{
pageIndex[processCount][k].index[i].proType = WRITABLE;
break;
}
case 2:
{
pageIndex[processCount][k].index[i].proType = EXECUTABLE;
break;
}
case 3:
{
pageIndex[processCount][k].index[i].proType= READABLE | WRITABLE;
break;
}
case 4:
{
pageIndex[processCount][k].index[i].proType= READABLE | EXECUTABLE;
break;
}
case 5:
{
pageIndex[processCount][k].index[i].proType= WRITABLE | EXECUTABLE;
break;
}
case 6:
{
pageIndex[processCount][k].index[i].proType= READABLE | WRITABLE | EXECUTABLE;
break;
}
default:
break;
}
/* 设置该页对应的辅存地址 */
pageIndex[processCount][k].index[i].auxAddr = processCount*256+(k*INDEX_PAGE+i)*4;
//pageTable[i].auxAddr = i * PAGE_SIZE ;
}
for (j = 0; j < BLOCK_SUM; j++)
{
/* 随机选择一些物理块进行页面装入 */
if (random() % 2 == 0)
{
q = j/INDEX_PAGE;
r = j%INDEX_PAGE;
do_page_in(&pageIndex[0][q].index[r], j);
pageIndex[0][q].index[r].blockNum = j;
pageIndex[0][q].index[r].filled = TRUE;
blockStatus[j] = TRUE;
}
else
blockStatus[j] = FALSE;
}
}
/* 初始化环境 */
void do_init()
{
int i, j ,k;
srand(time(NULL));
for(k=0;k<PAGE_SUM2;k++){
for (i = 0; i < PAGE_SUM1; i++)
{
pageTable[k][i].pageNum1 = i;
pageTable[k][i].pageNum2 = k;
pageTable[k][i].filled = FALSE;
pageTable[k][i].edited = FALSE;
pageTable[k][i].count = 0;
/* 使用随机数设置该页的保护类型 */
switch (rand() % 7)
{
case 0:
{
pageTable[k][i].proType = READABLE;
break;
}
case 1:
{
pageTable[k][i].proType = WRITABLE;
break;
}
case 2:
{
pageTable[k][i].proType = EXECUTABLE;
break;
}
case 3:
{
pageTable[k][i].proType = READABLE | WRITABLE;
break;
}
case 4:
{
pageTable[k][i].proType = READABLE | EXECUTABLE;
break;
}
case 5:
{
pageTable[k][i].proType = WRITABLE | EXECUTABLE;
break;
}
case 6:
{
pageTable[k][i].proType = READABLE | WRITABLE | EXECUTABLE;
break;
}
default:
break;
}
/* 设置该页对应的辅存地址 */
pageTable[k][i].processNum = rand() % 3;
pageTable[k][i].auxAddr = (i+k*8)* PAGE_SIZE ; //修改一：将*2去掉
pageTable[k][i].blockNum = 500; //修改三：将未被标记的改为500
}
}
for (j = 0; j < BLOCK_SUM; j++)
{
/* 随机选择一些物理块进行页面装入 */
if (rand() % 2 == 0)
{
do_page_in(&pageTable[j/8][j%8], j);
pageTable[j/8][j%8].blockNum = j;
pageTable[j/8][j%8].filled = TRUE;
blockStatus[j] = TRUE;
}
else
blockStatus[j] = FALSE;
}
}
void do_LRU_aging(Ptr_PageTableItem ptr_pageTabIt){
unsigned int i,j,page,popagenum;
unsigned int popage[PAGE_SUM] = {0};
unsigned int Mincount = AgingCountBit+1;
unsigned int Pagecount;
printf("没有空闲物理块，开始进行老化算法页面替换...\n");
for (i = 0,page = 0,popagenum=0; i < PAGE_SUM ; i++){
Pagecount = 0;
if (pageTable[i].filled && pageTable[i].LRU_flag ==0){
for(j=0;j<AgingCountBit;j++){
Pagecount += Aging_counter[pageTable[i].blockNum][j];
}
if (Pagecount<Mincount)
{
popagenum = 0;
popage[popagenum++] = i;
Mincount = Pagecount;
}
else if(pageTable == Mincount){
popage[popagenum++] = i;
}
}
}
if(popagenum>0){
page = popage[random()%popagenum];
}
else if (popagenum==0){ //没有找到未被使用的,随机选择一个
Mincount = AgingCountBit+1;
for (i = 0; i < PAGE_SUM; i++){
if (pageTable[i].filled){
for(j=0;j<AgingCountBit;j++){
Pagecount += Aging_counter[pageTable[i].blockNum][j];
}
if (Pagecount<Mincount){
popagenum = 0;
popage[popagenum++] = i;
Mincount = Pagecount;
}
else if(pageTable == Mincount){
popage[popagenum++] = i;
}
}
}
page = popage[random()%popagenum];
}
//随机选择一个
printf("选择第%u页进行替换\n", page);
//该页面对应的物理块修改了
if (pageTable[page].edited)
{
/* 页面内容有修改，需要写回至辅存 */
printf("该页内容有修改，写回至辅存\n");
do_page_out(&pageTable[page]);
}
pageTable[page].filled = FALSE;
pageTable[page].LRU_flag = 0;
/* 读辅存内容，写入到实存 */
do_page_in(ptr_pageTabIt, pageTable[page].blockNum);
/* 更新页表内容 */
ptr_pageTabIt->blockNum = pageTable[page].blockNum;
ptr_pageTabIt->filled = TRUE;
ptr_pageTabIt->edited = FALSE;
ptr_pageTabIt->LRU_flag = 0;
printf("页面替换成功\n");
}
/* 初始化环境 */
void do_init()
{
int i, j;
srandom(time(NULL));
/********************************************************************************/
//初始化辅存,不然程序运行不了
unsigned char c;
for (i = 0; i < 64 * 4; i++) {
c = random() % 0xFFu;
fprintf(ptr_auxMem, "%c", c);
}
/********************************************************************************/
//初始化二级页表
for (i = 0; i < PAGE_SUM; i++)
{
pageTable[i].pageNum = i;
pageTable[i].filled = FALSE;
pageTable[i].edited = FALSE;
pageTable[i].count = 0;
pageTable[i].LRU_flag = 0;
/* 使用随机数设置该页的保护类型 */
switch (random() % 7)
{
case 0:
{
pageTable[i].proType = READABLE;
break;
}
case 1:
{
pageTable[i].proType = WRITABLE;
break;
}
case 2:
{
pageTable[i].proType = EXECUTABLE;
break;
}
case 3:
{
pageTable[i].proType = READABLE | WRITABLE;
break;
}
case 4:
{
pageTable[i].proType = READABLE | EXECUTABLE;
break;
}
case 5:
{
pageTable[i].proType = WRITABLE | EXECUTABLE;
break;
}
case 6:
{
pageTable[i].proType = READABLE | WRITABLE | EXECUTABLE;
break;
}
default:
break;
}
/* 设置该页对应的辅存地址 */
/***********************************************************************************/
//pageTable[i].auxAddr = i * PAGE_SIZE * 2;
pageTable[i].auxAddr = i * PAGE_SIZE;
/***********************************************************************************/
/***********************************************************************************/
//随机产生进程号0~9
pageTable[i].proccessNum = random() % 10;
/***********************************************************************************/
}
for (i = 0; i < PAGE_SUM; ++i){
for (j = 0; j < AgingCountBit; ++j){
Aging_counter[i][j] = 0;//初始化老化算法计数位
}
}
for (j = 0; j < BLOCK_SUM; j++)
{
/* 随机选择一些物理块进行页面装入 */
if (random() % 2 == 0)
{
do_page_in(&pageTable[j], j);
pageTable[j].blockNum = j;
pageTable[j].filled = TRUE;
blockStatus[j] = TRUE;
}
else
blockStatus[j] = FALSE;
}
//初始化一级页表
for(i=0;i<8;i++){
firstPageTable[i].firstPageNum = i;
firstPageTable[i].secondPageNum[0] = 8*i+0;
firstPageTable[i].secondPageNum[1] = 8*i+1;
firstPageTable[i].secondPageNum[2] = 8*i+2;
firstPageTable[i].secondPageNum[3] = 8*i+3;
firstPageTable[i].secondPageNum[4] = 8*i+4;
firstPageTable[i].secondPageNum[5] = 8*i+5;
firstPageTable[i].secondPageNum[6] = 8*i+6;
firstPageTable[i].secondPageNum[7] = 8*i+7;
}
}
/* 初始化环境 */
void do_init()
{
int i, j;
srandom(time(NULL));
for(i=0;i<8;i++)//
{
prt_pageTable_1[i]=&pageTable[8*i];
}//将一级页表项指向二级页表的相应位置
for (i = 0; i < PAGE_SUM; i++)
{
pageTable[i].pageNum = i;
pageTable[i].filled = FALSE;
pageTable[i].edited = FALSE;
pageTable[i].count = 0;//LFU算法计数器
pageTable[i].count_1 = 0;//页面老化算法计数器
pageTable[i].count_LRU=0;//LRU算法计数器
pageTable[i].R = 0;//访问位
//随机设置某页属于哪些进程
switch (random() % 7)
{
case 0:
{
pageTable[i].proccessNum = PRO_0;
break;
}
case 1:
{
pageTable[i].proccessNum = PRO_1;
break;
}
case 2:
{
pageTable[i].proccessNum = PRO_2;
break;
}
case 3:
{
pageTable[i].proccessNum = PRO_0 | PRO_1;
break;
}
case 4:
{
pageTable[i].proccessNum = PRO_0 | PRO_2;
break;
}
case 5:
{
pageTable[i].proccessNum = PRO_1 | PRO_2;
break;
}
case 6:
{
pageTable[i].proccessNum = PRO_0 | PRO_1 | PRO_2;
break;
}
default:
break;
}
/* 使用随机数设置该页的保护类型 */
switch (random() % 7)
{
case 0:
{
pageTable[i].proType = READABLE;
break;
}
case 1:
{
pageTable[i].proType = WRITABLE;
break;
}
case 2:
{
pageTable[i].proType = EXECUTABLE;
break;
}
case 3:
{
pageTable[i].proType = READABLE | WRITABLE;
break;
}
case 4:
{
pageTable[i].proType = READABLE | EXECUTABLE;
break;
}
case 5:
{
pageTable[i].proType = WRITABLE | EXECUTABLE;
break;
}
case 6:
{
pageTable[i].proType = READABLE | WRITABLE | EXECUTABLE;
break;
}
default:
break;
}
/* 设置该页对应的辅存地址 */
pageTable[i].auxAddr = i * PAGE_SIZE ;//12:15
}
for (j = 0; j < BLOCK_SUM; j++)
{
/* 随机选择一些物理块进行页面装入 */
if (random() % 2 == 0)
{
do_page_in(&pageTable[j], j);
pageTable[j].blockNum = j;
pageTable[j].filled = TRUE;
blockStatus[j] = TRUE;
}
else
blockStatus[j] = FALSE;
}
}
/* 初始化环境 */
void do_init()
{
srand((unsigned int) time(NULL));
for(int i = 0; i < QUICK_SUM; i++) {
quick[i].blockNum = 0;
quick[i].pageNum = 0;
quick[i].program = 0;
quick[i].time = 0;
quick[i].feature = 0;
}
for (int i = 0; i < PAGE_SUM; i++)
{
pageTable1[i].pageNum = i;
pageTable1[i].filled = false;
pageTable1[i].edited = false;
pageTable1[i].count = 0;
/* 使用随机数设置该页的保护类型 */
switch (rand() % 7)
{
case 0:
{
pageTable1[i].proType = READABLE;
break;
}
case 1:
{
pageTable1[i].proType = WRITABLE;
break;
}
case 2:
{
pageTable1[i].proType = EXECUTABLE;
break;
}
case 3:
{
pageTable1[i].proType = READABLE | WRITABLE;
break;
}
case 4:
{
pageTable1[i].proType = READABLE | EXECUTABLE;
break;
}
case 5:
{
pageTable1[i].proType = WRITABLE | EXECUTABLE;
break;
}
case 6:
{
pageTable1[i].proType = READABLE | WRITABLE | EXECUTABLE;
break;
}
default:
break;
}
/* 设置该页对应的辅存地址 */
pageTable1[i].auxAddr = i * PAGE_SIZE * 2;
}
for (int i = 0; i < PAGE_SUM; i++)
{
pageTable2[i].pageNum = i;
pageTable2[i].filled = false;
pageTable2[i].edited = false;
pageTable2[i].count = 0;
/* 使用随机数设置该页的保护类型 */
switch (rand() % 7)
{
case 0:
{
pageTable2[i].proType = READABLE;
break;
}
case 1:
{
pageTable2[i].proType = WRITABLE;
break;
}
case 2:
{
pageTable2[i].proType = EXECUTABLE;
break;
}
case 3:
{
pageTable2[i].proType = READABLE | WRITABLE;
break;
}
case 4:
{
pageTable2[i].proType = READABLE | EXECUTABLE;
break;
}
case 5:
{
pageTable2[i].proType = WRITABLE | EXECUTABLE;
break;
}
case 6:
{
pageTable2[i].proType = READABLE | WRITABLE | EXECUTABLE;
break;
}
default:
break;
}
/* 设置该页对应的辅存地址 */
pageTable2[i].auxAddr = i * PAGE_SIZE * 2;
}
for (int j = 0; j < BLOCK_SUM; j++)
{
/* 随机选择一些物理块进行页面装入 */
if (rand() % 3 == 0)
{
if(rand() % 2 == 0)
{
tag = 1;
do_page_in(&pageTable1[j], j);
pageTable1[j].blockNum = j;
pageTable1[j].filled = true;
blockStatus[j] = true;
}
else
{
tag = 2;
do_page_in(&pageTable2[j], j);
pageTable2[j].blockNum = j;
pageTable2[j].filled = true;
blockStatus[j] = true;
}
}
else
blockStatus[j] = false;
}
}
//修改了二级页表
void do_init()
{
int i, j,k;
unsigned long auxAddr=0;
srandom(time(NULL));//设置用于生成随机序列的种子
for (i = 0; i < ROOT_PAGE_SUM; i++)
{
for(k = 0; k<CHILD_PAGE_SUM; k++){
pageTable[i][k].rootpageNum = i;
pageTable[i][k].childpageNum = k;
pageTable[i][k].filled = FALSE;//页面装入的特征位
pageTable[i][k].edited = FALSE;//页面修改标示
pageTable[i][k].count = 0;//页面的使用次数
// initial processNum
if (random() % 2 == 0) {
pageTable[i][k].processNum = 0;
}
else pageTable[i][k].processNum = 1;
/* 随机将页面保护类型设置为以下其中情况中的一种 */
switch (random() % 7)
{
case 0:
{
pageTable[i][k].proType = READABLE;
break;
}
case 1:
{
pageTable[i][k].proType = WRITABLE;
break;
}
case 2:
{
pageTable[i][k].proType = EXECUTABLE;
break;
}
case 3:
{
pageTable[i][k].proType = READABLE | WRITABLE;
break;
}
case 4:
{
pageTable[i][k].proType = READABLE | EXECUTABLE;
break;
}
case 5:
{
pageTable[i][k].proType = WRITABLE | EXECUTABLE;
break;
}
case 6:
{
pageTable[i][k].proType = READABLE | WRITABLE | EXECUTABLE;
break;
}
default:
break;
}
/* 设置该页对应的辅存地址 */
//这已经是一个二级页表了，辅存和页表项之间的对应关系已经不再单纯了；
//pageTable[i][k].auxAddr = (i*16+k)*PAFE_SIZE;
pageTable[i][k].auxAddr = auxAddr;
auxAddr += PAGE_SIZE;
}
}
for (j = 0; j < BLOCK_SUM; j++)//用来作为物理块号的
{
/* 随机选择一些物理块装入实存地址*/
if (random() % 2 == 0)
{
i = random() % ROOT_PAGE_SUM;
k = random() % CHILD_PAGE_SUM;
do_page_in(&pageTable[i][k], j);
pageTable[i][k].blockNum = j;
pageTable[i][k].filled = TRUE;
blockStatus[j] = TRUE;
LRU_ChangeAdd(j);
}
else
blockStatus[j] = FALSE;
}
}
/* 初始化环境 */
void do_init()
{
int i, j, k, pro;
srandom(time(NULL));
for (i = 0; i < 8; i++)
{
for (j = 0; j < 8; j++)
{
for (k = 0; k < 8; k++)
{
fullpageTable[i][j][k].pageNum = 8*j + k;
fullpageTable[i][j][k].filled = FALSE;
fullpageTable[i][j][k].edited = FALSE;
fullpageTable[i][j][k].count = 0;
/* 使用随机数设置该页的保护类型 */
switch (random() % 7)
{
case 0:
{
fullpageTable[i][j][k].proType = READABLE;
break;
}
case 1:
{
fullpageTable[i][j][k].proType = WRITABLE;
break;
}
case 2:
{
fullpageTable[i][j][k].proType = EXECUTABLE;
break;
}
case 3:
{
fullpageTable[i][j][k].proType = READABLE | WRITABLE;
break;
}
case 4:
{
fullpageTable[i][j][k].proType = READABLE | EXECUTABLE;
break;
}
case 5:
{
fullpageTable[i][j][k].proType = WRITABLE | EXECUTABLE;
break;
}
case 6:
{
fullpageTable[i][j][k].proType = READABLE | WRITABLE | EXECUTABLE;
break;
}
default:
break;
}
/* 设置该页对应的辅存地址 */
fullpageTable[i][j][k].auxAddr = (i*8 + j*8 + k) * PAGE_SIZE;
}
}
}
pageTable = fullpageTable;
for (j = 0; j < BLOCK_SUM; j++)
{
/* 随机选择一些物理块进行页面装入 */
// pro = random() % 8;
i = j / 8; k = j % 8;
if (random() % 2 == 0)
{
do_page_in(&pageTable[0][i][k], j);
pageTable[0][i][k].blockNum = j;
pageTable[0][i][k].filled = TRUE;
blockStatus[j] = TRUE;
}
else
blockStatus[j] = FALSE;
}
}
/* 初始化环境 */
void do_init()
{
int i, j;
srandom(time(NULL));
for (i = 0; i < PAGE_SUM; i++)
{
pageTable[i].pageNum = i;
pageTable[i].filled = FALSE;
pageTable[i].edited = FALSE;
pageTable[i].count = 0;
/* 使用随机数设置该页的保护类型 */
switch (random() % 7)
{
case 0:
{
pageTable[i].proType = READABLE;
break;
}
case 1:
{
pageTable[i].proType = WRITABLE;
break;
}
case 2:
{
pageTable[i].proType = EXECUTABLE;
break;
}
case 3:
{
pageTable[i].proType = READABLE | WRITABLE;
break;
}
case 4:
{
pageTable[i].proType = READABLE | EXECUTABLE;
break;
}
case 5:
{
pageTable[i].proType = WRITABLE | EXECUTABLE;
break;
}
case 6:
{
pageTable[i].proType = READABLE | WRITABLE | EXECUTABLE;
break;
}
default:
break;
}
/* 设置该页对应的辅存地址 */
pageTable[i].auxAddr = i * PAGE_SIZE * 2;
}
for (j = 0; j < BLOCK_SUM; j++)
{
/* 随机选择一些物理块进行页面装入 */
if (random() % 2 == 0)
{
do_page_in(&pageTable[j], j);
pageTable[j].blockNum = j;
pageTable[j].filled = TRUE;
blockStatus[j] = TRUE;
}
else
blockStatus[j] = FALSE;
}
}
/* 初始化环境 */
void do_init()
{
int i, j,k;
srand(time(NULL));
for(i=0;i<BLOCK_SUM;i++)
{
whichprogress[i]=rand()%VIRTUAL_PROGRESSES;
}
for(j=0;j<VIRTUAL_PROGRESSES;j++)
for (i = 0; i < LV1_PAGE_SUM; i++)
{
pageTableface[j][i].pageNum = i;
pageTableface[j][i].filled = FALSE;
pageTableface[j][i].edited = FALSE;
pageTableface[j][i].count = 0;
/* 使用随机数设置该页的保护类型 */
/*switch (rand() % 7)
{
case 0:
{
pageTable[i].proType = READABLE;
break;
}
case 1:
{
pageTable[i].proType = WRITABLE;
break;
}
case 2:
{
pageTable[i].proType = EXECUTABLE;
break;
}
case 3:
{
pageTable[i].proType = READABLE | WRITABLE;
break;
}
case 4:
{
pageTable[i].proType = READABLE | EXECUTABLE;
break;
}
case 5:
{
pageTable[i].proType = WRITABLE | EXECUTABLE;
break;
}
case 6:
{
pageTable[i].proType = READABLE | WRITABLE | EXECUTABLE;
break;
}
default:
break;
}*/
/* 设置该页对应的辅存地址 */
//pageTable[i].auxAddr = i * PAGE_SIZE * 2;
//pageTable[i].progressNum = rand() % VIRTUAL_PROGRESSES;
}
for(k=0;k<VIRTUAL_PROGRESSES;k++)
for (i = 0; i < LV1_PAGE_SUM; i++){
for (j = 0; j < LV2_PAGE_SUM; j++){
pageTable[k][i][j].pageNum = i * LV1_PAGE_SUM + j;
pageTable[k][i][j].filled = FALSE;
pageTable[k][i][j].edited = FALSE;
pageTable[k][i][j].count = 0;
switch (rand() % 7)
{
case 0:
{
pageTable[k][i][j].proType = READABLE;
break;
}
case 1:
{
pageTable[k][i][j].proType = WRITABLE;
break;
}
case 2:
{
pageTable[k][i][j].proType = EXECUTABLE;
break;
}
case 3:
{
pageTable[k][i][j].proType = READABLE | WRITABLE;
break;
}
case 4:
{
pageTable[k][i][j].proType = READABLE | EXECUTABLE;
break;
}
case 5:
{
pageTable[k][i][j].proType = WRITABLE | EXECUTABLE;
break;
}
case 6:
{
pageTable[k][i][j].proType = READABLE | WRITABLE | EXECUTABLE;
break;
}
default:
break;
}
pageTable[k][i][j].auxAddr = (i * LV1_PAGE_SIZE + j * LV2_PAGE_SIZE) ;
//pageTable[k][i][j].progressNum = rand() % VIRTUAL_PROGRESSES;
}
}
for (j = 0; j < BLOCK_SUM; j++)
{
/* 随机选择一些物理块进行页面装入 */
if (rand() % 2 == 0)
{
do_page_in(&pageTable[whichprogress[j]][j / LV1_PAGE_SUM][j % LV1_PAGE_SUM], j);
pageTable[whichprogress[j]][j / LV1_PAGE_SUM][j % LV1_PAGE_SUM].blockNum = j;
pageTable[whichprogress[j]][j / LV1_PAGE_SUM][j % LV1_PAGE_SUM].filled = TRUE;
blockStatus[j] = TRUE;
}
else
blockStatus[j] = FALSE;
}
for(i=0;i<VIRTUAL_PROGRESSES;i++)
for (j = 0; j < PAGE_SUM; j++)
{
for(k=0;k<8;k++)
{
actmemcount[i][j][k]=0;
}
}
}
