操作系统实验页面置换算法C++代码
页面置换算法模拟实验报告
if(block[i].timer >= block[pos].timer)
pos = i;//找到应予置换页面，返回BLOCK中位置
return pos;
}
void PRA::display(void)
{
for(int i=0; i<Bsize; i++)
}
}
int PRA::findSpace(void)
{
for(int i=0; i<Bsize; i++)
if(block[i].content == -1)
return i;//找到空闲内存，返回BLOCK中位置
return -1;
}
int PRA::findExist(int curpage)
{
if(exist != -1)
{
cout<<"不缺页"<<endl;
}
else
{
space = findSpace();
if(space != -1)
{
block[space] = page[i];
display();
}
else
{
for(int k=0; k<Bsize; k++)
for(int j=i; j<Psize; j++)
int findReplace(void); //查找应予置换的页面
void display(void); //显示
void FIFO(void);//FIFO算法
【精品】页面置换算法实验报告
【精品】页面置换算法实验报告一、实验目的了解操作系统中的页面置换算法，并实现FIFO、LRU和Clock算法。
二、实验原理页面置换算法是操作系统中用到的一种算法，其作用是在内存不够用时，选择牺牲已经在内存中的一些页，腾出更多的空间给新的内容。
本次实验主要实现了FIFO、LRU和Clock算法。
1、FIFO算法FIFO算法是最简单的页面置换算法，它采用先进先出的原则，即最先进入内存的页面应该最早被替换出去。
该算法的实现非常简单，只需要维护一个队列即可。
当需要置换页面时，选择队列的第一个页面进行替换即可。
2、LRU算法LRU算法是Least Recently Used的缩写，即最近最少使用算法。
该算法的核心思想是选择最久没有被使用的页面进行替换。
为了实现该算法，需要维护记录页面使用时间的链表、栈或队列等结构。
3、Clock算法Clock算法也叫做二次机会算法，是一种改良的FIFO算法。
它是基于FIFO算法的思想，并且每个页面都设置了一个使用位（use bit），用于记录该页面是否被使用过。
当需要置换一个页面时，检查该页面的使用位，如果该页面的使用位为1，则将该页面的使用位设置为0并移到队列的末尾，表示该页面有“二次机会”继续待在内存中；如果该页面的使用位为0，则选择该页面进行替换。
三、实验过程本次实验采用Python语言实现页面置换算法，并使用样例进行测试。
1、FIFO算法实现FIFO算法的实现非常简单，只需要用一个队列来维护已经在内存中的页面，当需要置换页面时，选择队列的第一个元素即可。
代码如下：```pythonfrom collections import dequeclass FIFO:def __init__(self, frame_num):self.frame_num = frame_numself.frames = deque(maxlen=frame_num)def access(self, page):if page in self.frames:return Falseif len(self.frames) >= self.frame_num:self.frames.popleft()self.frames.append(page)return True```2、LRU算法实现LRU算法的实现需要维护一个记录页面使用时间的链表或队列。
操作系统实验参考代码
目录实验一WINDOWS进程初识 (2)实验二进程管理 (6)实验三进程同步的经典算法 (10)实验四存储管理 (14)试验五文件系统试验 (18)实验有关（参考）代码实验一WINDOWS进程初识1、实验目的（1）学会使用VC编写基本的Win32 Consol Application（控制台应用程序)。
（2）掌握WINDOWS API的使用方法。
（3）编写测试程序，理解用户态运行和核心态运行。
2、程序清单清单1-1 一个简单的Windows控制台应用程序// hello项目# include <iostream>void main(){std::cout << “Hello, Win32 Consol Application” << std :: endl ;}清单1-2 核心态运行和用户态运行时间比计算// proclist项目# include <windows.h># include <tlhelp32.h># include <iostream.h>// 当在用户模式机内核模式下都提供所耗时间时，在内核模式下进行所耗时间的64位计算的帮助方法DWORD GetKernelModePercentage(const FILETIME& ftKernel,const FILETIME& ftUser){// 将FILETIME结构转化为64位整数ULONGLONG qwKernel=(((ULONGLONG)ftKernel.dwHighDateTime)<<32)+ftKernel.dwLowDateTime;ULONGLONG qwUser=(((ULONGLONG)ftUser.dwHighDateTime)<<32)+ftUser.dwLowDateTime;// 将消耗时间相加，然后计算消耗在内核模式下的时间百分比ULONGLONG qwTotal=qwKernel+qwUser;DWORD dwPct=(DWORD)(((ULONGLONG)100*qwKernel)/qwTotal);return(dwPct);}// 以下是将当前运行过程名和消耗在内核模式下的时间百分数都显示出来的应用程序void main(int argc,char *argv[]){if(argc<2){cout<<"请给出你要查询的程序名"<<endl;exit(0);}// 对当前系统中运行的过程拍取“快照”HANDLE hSnapshot=::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,// 提取当前过程0);// 如果是当前过程，就将其忽略// 初始化过程入口PROCESSENTRY32 pe;::ZeroMemory(&pe,sizeof(pe));pe.dwSize=sizeof(pe);BOOL bMore=::Process32First(hSnapshot,&pe);BOOL found = FALSE;while(bMore){// 打开用于读取的过程if(!strcmp(pe.szExeFile,argv[1])){found = TRUE;HANDLE hProcess=::OpenProcess(PROCESS_QUERY_INFORMA TION,// 指明要得到信息FALSE,// 不必继承这一句柄pe.th32ProcessID);// 要打开的进程if (hProcess!=NULL){// 找出进程的时间FILETIME ftCreation,ftKernelMode,ftUserMode,ftExit;::GetProcessTimes(hProcess,// 所感兴趣的进程&ftCreation,// 进程的启动时间&ftExit,// 结束时间(如果有的话)&ftKernelMode,// 在内核模式下消耗的时间&ftUserMode);// 在用户模式下消耗的时间// 计算内核模式消耗的时间百分比DWORD dwPctKernel=::GetKernelModePercentage(ftKernelMode,// 在内核模式上消耗的时间ftUserMode);// 在用户模式下消耗的时间// 向用户显示进程的某些信息cout<< "process ID: " << pe.th32ProcessID<< ",EXE file:" << pe.szExeFile<< ",%d in Kernel mode: " << dwPctKernel << endl;// 消除句柄::CloseHandle(hProcess);}}// 转向下一个进程bMore=::Process32Next(hSnapshot,&pe);}if(found==FALSE){cout<<"当前系统没有这个可执行程序正在运行"<<endl;exit(0);}}清单1-3 核心态运行和用户态运行时间测试程序#include <stdio.h>main(){int i,j;while(1){for(i=0;i<1000;i++);for(j=1;j<1000;j++) printf(“enter kernel mode running.”);}}实验二进程管理1、实验目的1) 通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作，进一步熟悉操作系统的进程概念，理解Windows进程的“一生”。
页面置换算法实验源代码
#include <stdio.h>#include <stdlib.h>#include <time.h>#include <malloc.h>#define M 4 //物理页数#define N 20 //需要调入的页数#define LEN sizeof(struct node)/** @auther by 12281201 sunyangwei*/typedef struct page{int num;int time;}Page; //物理页项，包括调入的页号和时间struct node //定义空闲链表数据结构{int num;struct node *next;};Page mm[M]; //3个物理页int K=0,S=0,T=0,Q=0; //记录缺页率int pos=0;//记录存在最长时间项//初始化内存页表项及存储内存情况的空间void INIT(){int i;for(i=0;i<M;i++){mm[i].num =-1;mm[i].time =0;}}//建立链表struct node* create(){struct node *head;head = (struct node*)malloc(LEN);head->next = NULL;return (head);}//打印链表void print(struct node * head)struct node * p;printf("Now,链表页面:");p=head->next;if(p==NULL){printf("链表为空\n");}else {do{printf("%3d",p->num);p=p->next;}while(p!=NULL);}printf("\n");}//链表插入结点（页）struct node* insert(struct node* head,struct node * newnode){struct node *p1;p1=head->next;if(p1==NULL)//原来的链表是空表,新的节点直接插到头结点后面{head->next=newnode;newnode->next = NULL;}else//如果不是空表，则遍历寻找合适的插入位置{while((p1->next!=NULL)){p1=p1->next;//后移}p1->next = newnode;newnode->next = NULL;}return(head);}//删除结点struct node* delete(struct node* head,int num){struct node *p1,*p2;p1=head->next;p2 = head;while(p1!=NULL&&num!=p1->num){p2=p1;p1=p1->next;}if(p1!=NULL&&num==p1->num){p2->next=p1->next;}return (head);}//取得内存中存在时间最久的位置int GetMax(){int max=-1;int i;for(i=0;i<M;i++){if(mm[i].time > max){max=mm[i].time ;pos=i;}}return pos;}//检查最长时间不使用页面int longesttime(int i,int array[]){int max=-1;mm[0].time=0;mm[1].time=0;mm[2].time=0;for(int q=0;q<M;q++){for(int count=i;count<N;count++){if(mm[q].num==array[count]){mm[q].time=count;break;}}}for(int iii=0;iii<M;iii++){if(mm[iii].time==0){pos = iii;break;}else if((mm[iii].time!=0) && (mm[iii].time>max) ){max=mm[iii].time;pos=iii;}}return pos;}int getPrePos(int i,int array[])//得到最久没有使用的页面位置{int min=20;mm[0].time=0;mm[1].time=0;mm[2].time=0;for(int r=0;r<M;r++){for(int p=i;p>=0;p--){if(mm[r].num == array[p]){mm[r].time = p;break;}}}for(int j=0;j<M;j++){if(mm[j].time<min){min = mm[j].time;pos=j;}}return pos;}int is_intable(int pagenum,struct node * head){struct node *temp;temp=head->next;/*取得链表的头指针*/while(temp!=NULL)/*只要是非空表*/{if(pagenum ==temp->num){return 1;}temp=temp->next;/*跟踪链表增长*/}return 0;}//检查某页是否在内存，不存在返回-1,存在返回物理块编号int Equation(int fold){int i;for(i=0;i<M;i++){if(mm[i].num == fold)return i;}return -1;}//检查物理内存是否已满,-1表满，其他不满int Check(){int i;for(i=0;i<M;i++){if(mm[i].num == -1)return i;}return -1;}//先进先出void FIFO(int fold){int i;int a,b,c;a=Equation(fold);//a代表物理块编号//页已存在if(a != -1){}//页不存在b=Check();//内存还有空闲if(b != -1){mm[b].num = fold;}//内存已满，需要置换else {c=GetMax();mm[c].num = fold;mm[c].time = 0;K++;}}printf("访问页面%d",fold);for(int j=0;j<M;j++){printf("%3d",mm[j].num);}printf("\n");for(i=0;i<M;i++){if(mm[i].num != -1){mm[i].time ++;}}}void OPT(int i,int array[]){int a,b,c;a=Equation(array[i]);if(a == -1){//页不在内存b=Check();//内存还有空闲if(b != -1){mm[b].num = array[i];}//内存已满，需要置换else{c=longesttime(i,array);mm[c].num = array[i];T++;}printf("访问页面%d",array[i]);for(int j=0;j<M;j++){printf("%3d",mm[j].num);}printf("\n");}void LRU(int i,int array[]){int a,b,c;a = Equation(array[i]);if(a == -1){//页不在内存b=Check();//内存还有空闲if(b != -1){mm[b].num = array[i];}//内存已满，需要置换else{c=getPrePos(i,array);mm[c].num = array[i];S++;}}printf("访问页面%d",array[i]);for(int j=0;j<M;j++){printf("%3d",mm[j].num);}printf("\n");}void PBA(int i,int array[],struct node * head)//与fifo算法类似，只是置换下来的页面存放在链表里面{int a,c;struct node * newnode;if(Equation(array[i]) !=-1){}//页已在内存else {//页不在内存a=Check();if(a != -1){//检查内存是否有空闲，有空闲，则不需要调换mm[a].num = array[i];}else{//内存没有空闲，需要置换页面//页面在链表里面if(is_intable(array[i],head)==1) {//页面在链表里面c=GetMax();//得到物理块中要被置换出来的页面//从链表里删除节点（页面）head = delete(head,array[i]);//在表尾插入置换下来的节点（页面）newnode=(struct node*)malloc(LEN);newnode->num= mm[c].num;head = insert(head,newnode);mm[c].num =array[i];mm[c].time = 0;}else{//不在链表里面c=GetMax();newnode=(struct node*)malloc(LEN);newnode->num= mm[c].num;head = insert(head,newnode);mm[c].num = array[i];mm[c].time = 0;Q++;printf("Q:%d\n",Q);print(head);}}}printf("访问页面%d",array[i]);for(int j=0;j<M;j++){printf("%3d",mm[j].num);}printf("\n");for(int p=0;p<M;p++){if(mm[p].num != -1){mm[p].time ++;}}}/*符合局部访问特性的随机生成算法确定虚拟内存的尺寸pageNum，工作集的起始位置p，工作集中包含的页数e，工作集移动率m（每处理m个页面访问则将起始位置p +1），以及一个范围在0和1之间的值t；生成m个取值范围在p和p + e间的随机数，并记录到页面访问序列串中；生成一个随机数r，0 ≤r ≤1；如果r < t，则为p生成一个新值，否则p = (p + 1) mod N；如果想继续加大页面访问序列串的长度，请返回第2步，否则结束。
页面置换算法实验(内含完整代码)
实验二存储管理一、实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。
二、实验内容基于一个虚拟存储区和内存工作区，设计下述算法并计算访问命中率。
1、最佳淘汰算法（OPT）2、先进先出的算法（FIFO）3、最近最久未使用算法（LRU）4、简单时钟(钟表)算法（CLOCK）命中率＝１－页面失效次数／页地址流(序列)长度三、实验原理简述UNIX中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时，发现其所在页面不在内存，就立即提出请求（向CPU发出缺中断），由系统将其所需页面调入内存。
这种页面调入方式叫请求调页。
为实现请求调页，核心配置了四种数据结构：页表、页帧（框）号、访问位、修改位、有效位、保护位等。
当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转入缺页中断处理程序。
该程序通过查找页表，得到该页所在外存的物理块号。
如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调入内存，然后修改页表。
如果内存已满，则须按某种置换算法从内存中选出一页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调入，修改页表。
利用修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。
整个页面的调入过程对用户是透明的。
四、算法描述本实验的程序设计基本上按照实验内容进行。
即使用srand( )和rand( )函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。
（1）通过随机数产生一个指令序列，共320条指令。
指令的地址按下述原则生成：A：50%的指令是顺序执行的B：25%的指令是均匀分布在前地址部分C：25%的指令是均匀分布在后地址部分具体的实施方法是：A：在[0，319]的指令地址之间随机选取一起点mB：顺序执行一条指令，即执行地址为m+1的指令C：在前地址[0,m+1]中随机选取一条指令并执行，该指令的地址为m’D：顺序执行一条指令，其地址为m’+1E：在后地址[m’+2，319]中随机选取一条指令并执行F：重复步骤A-E，直到320次指令（2）将指令序列变换为页地址流设：页面大小为1K；用户内存（页帧）容量为4页~32页；用户虚存容量为32K。
操作系统页面置换算法实验报告
学生实验报告姓名：年级专业班级学号成绩【实验结果或总结】（对实验结果进行相应分析，或总结实验的心得体会，并提出实验的改进意见1.程序的执行结果如下：(1)先进先出页面置换算法(2)最佳页面置换法(3)最近最久未使用置换算法2.以上三个程序通过数组和排序语句实现页面的三种基本调度算法。
(1)先进先出算法事先设定标志k=3，页面每发生一次置换k值增加1。
通过取k对3的余数来确定被置换的内存中的页面，当被访问页面存在于内存时，不置换，而直接输出原内存中的3个页面。
(2)最佳置换算法通过设定c1,c2,c3来记录当前内存中的页面被下一次访问的位置(时间)，通过对c1,c2,c3的大小比较确定内存中需要被置换的页面。
三者中值最大的对应的内存页面选择被置换。
即实现了未来最长时间未访问的机制，即最佳置换算法。
(3)最近最久未使用置换算法的原理跟最佳置换算法类似。
初始设定变量c1,c2,c3记录当前内存中的以前的最近一次未被访问的位置(时间)，比较三者的大小来确定需要被置换的页面。
三者中至最小的对应的内存页面选择被置换。
即实现了最近最久未使用的机制，即最近最久未使用置换算法。
3.上述三个程序分别能较好的模拟页面的基本调度算法，实现页面的置换，保证进程的正常执行。
但也分别存在一些不足。
(1)当内存中三个页面有部分相同时，程序不能很好的实现调度。
即c1,c2,c3中有部分变量值相等，源程序可能不能准确的找到调度顺序，如图所示。
(LRU算法)改进的方法为在c1,c2,c3间的大小比较判断语句中增加关系语句的默认处理办法，当三者间有部分相同时，默认选择按从前到后的顺序执行。
比如当c2=c3的时候选择页面a[2]进行置换。
当c1=c2=c3时则选择页面a[0]进行置换。
也就相当于无法运用LRU算法调用的时候折衷采取先进先出置换算法，以实现页面的合理调度，提高页面的利用效率。
指导教师签名：20 年月日【备注】。
页面置换算法实验报告
页面置换算法实验报告一、实验目的本次实验的目的是通过模拟页面置换算法的过程，了解不同算法的优缺点，掌握算法的实现方法，以及对算法的性能进行评估。
二、实验原理页面置换算法是操作系统中的一个重要概念，它是为了解决内存不足的问题而产生的。
当系统中的进程需要使用内存时，如果内存已经被占满，就需要将一些页面从内存中置换出去，以便为新的页面腾出空间。
页面置换算法就是用来决定哪些页面应该被置换出去的算法。
常见的页面置换算法有以下几种：1. 最佳置换算法（OPT）最佳置换算法是一种理论上的最优算法，它总是选择最长时间内不会被访问的页面进行置换。
但是，由于无法预测未来的页面访问情况，因此最佳置换算法无法在实际中使用。
2. 先进先出置换算法（FIFO）先进先出置换算法是一种简单的置换算法，它总是选择最先进入内存的页面进行置换。
但是，这种算法容易出现“抖动”现象，即频繁地将页面置换出去，然后再将其置换回来。
3. 最近最久未使用置换算法（LRU）最近最久未使用置换算法是一种比较常用的置换算法，它总是选择最长时间未被访问的页面进行置换。
这种算法可以避免“抖动”现象，但是实现起来比较复杂。
4. 时钟置换算法（Clock）时钟置换算法是一种改进的FIFO算法，它通过维护一个环形链表来实现页面置换。
当需要置换页面时，算法会从当前位置开始扫描链表，如果找到一个未被访问的页面，则将其置换出去。
如果扫描一圈后都没有找到未被访问的页面，则将当前位置的页面置换出去。
三、实验过程本次实验使用Python语言编写了一个页面置换算法模拟程序，可以模拟上述四种算法的过程，并输出算法的性能指标。
程序的主要流程如下：1. 读取输入文件，获取页面访问序列和内存大小等参数。
2. 根据选择的算法，初始化相应的数据结构。
3. 遍历页面访问序列，模拟页面置换的过程。
4. 输出算法的性能指标，包括缺页率、页面置换次数等。
下面分别介绍四种算法的实现方法。
1. 最佳置换算法（OPT）最佳置换算法需要预测未来的页面访问情况，因此需要遍历整个页面访问序列，找到最长时间内不会被访问的页面。
页面置换算法模拟实现
页面置换算法模拟实现学院专业学号学生姓名指导教师姓名2014年3月 19日一．课程设计的目的：操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。
l 进一步巩固和复习操作系统的基础知识。
l 培养学生结构化程序、模块化程序设计的方法和能力。
l 提高学生调试程序的技巧和软件设计的能力。
l 提高学生分析问题、解决问题以及综合利用C 语言进行程序设计的能力。
二．设计内容：根据设计要求实现对页面置换算法的模拟三 .设计要求：设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程，并计算访问命中率。
用C 语言实现，要求设计主界面以灵活选择某算法，且以下算法都要实现1、先进先出算法（FIFO）；2、最近最久未使用算法（LRU）3、最佳置换算法（OPT）四、程序流程图1、主函数2、FIFO3、LRU五、系统测试程序进行实例如下：1.开始界面，按任意键继续：2.算法结果：运行界面：（1）FIFO算法结果：（2）OPT算法结果：（3）LRU算法结果六. 源程序及系统文件使用说明#include< iostream.h >#include"stdlib.h"typedef int QElemType;#define ok 1#define overflow 0#define error 0typedef struct Qnode { QElemType data;struct Qnode *next;}Qnode,*Queueptr;typedef struct {Queueptr front;Queueptr rear;}LinkQueue;InitQueue( LinkQueue &Q ) {Q.front = Q.rear = ( Queueptr )malloc( sizeof( Qnode )); if( !Q.front ) exit ( overflow );Q.front->next =NULL;return ok;}EnQueue( LinkQueue &Q,QElemType e ) {Queueptr p;p = ( Queueptr )malloc( sizeof( Qnode ));if( !p ) exit( overflow );p->data = e;p->next = NULL;Q.rear->next = p;Q.rear = p;return ok;}DeQueue( LinkQueue &Q,QElemType &e ) {Queueptr p;if( Q.front == Q.rear ) return error;p = Q.front->next;e = p->data;Q.front->next = p->next;if( Q.rear == p ) Q.rear = Q.front;free( p );return ok;}void VisitQueue( LinkQueue Q ) {Queueptr p;p = Q.front->next;while( p ) { cout << p->data << " ";p = p->next; } }CompareQueue( LinkQueue Q,int page ) {Queueptr p;p = Q.front->next;while( p ) {if( p->data == page ) return ok;p = p->next;}return error;}void FIFO( int *a,int n,int m ) {LinkQueue Q;int page, t = 0,flag = 0,x;InitQueue( Q );for( int i = 1;i <= m;i++ ){page = a[ i ];t++;if( t <= n ) { EnQueue( Q,page );cout << a[ i ] << " "; }else {for( int j = 1;j <= n;j++ )if( CompareQueue( Q,page ) ) { t--;flag = 1;break; }if( flag == 0 ) { DeQueue( Q,x );cout << x << " was taken out "<< page << " was taken in";EnQueue( Q,page );}cout << endl;VisitQueue( Q );cout << ":";}flag = 0;}cout << "缺页中断数为:" << endl;cout << "t= " << t << endl;}void LRU( int *a,int n,int m ) {LinkQueue Q;int page, t = 0,flag = 0,x,e;InitQueue( Q );for( int i = 1;i <= m;i++ ){page = a[ i ];t++;if( t <= n ) { EnQueue( Q,page );cout << a[ i ] << " "; } else { for( int j = 1;j <= n;j++ )if( CompareQueue( Q,page ) ) { t--;DeQueue(Q,e);EnQueue(Q,e);flag = 1;break; }if( flag == 0 ) { DeQueue( Q,x );cout << x << " was taken out " << page << " was taken in";EnQueue( Q,page );}cout << endl;VisitQueue( Q );cout << ":";}flag = 0;}cout << "缺页中断数为:" << endl;cout << "t= " << t << endl;}int max( int *t,int n ){int max =t[ 1 ],s = 1;for( int i = 1;i <= n;i++ )if( t[ i ] > max ) {max = t[ i ];s = i;} return s;}void OPT( int a[ 21 ],int n,int m ) {int w = 0,flag = 0;int *t =new int[ n + 1 ];for( int i = 1;i <= m;i++ ){w++;if( w <= n ) cout << a[ i ] << " " ;else{for( int q = 1;q <= n;q++ )if( a[ i ] == a[ q ] ) { w--;flag = 1;break; }if( flag == 0 ){for( int j = 1;j <= n;j++ )for( int k = i;k <= m;k++ ){if( a[ j ] != a[ k ] ) t[ j ]++;else break;}cout << a[ max( t,n ) ] << " " << "was taken out" << " " << a[ i ] << " was taken in ";a[ max( t,n ) ] = a[ i ];}cout << endl;for( int s = 1;s <= n;s++ )cout << a[ s ] << " ";cout << ":";}for( int r = 1;r <= n;r++ ) t[ r ] = 0; flag = 0;}cout << "缺页中断数为:" << endl;cout << "w = " << w << endl;delete [] a;}main(){int m,n;cout << "输入页面数：" << endl;cin >> m;int *a = new int[ m + 1 ];cout << "输入驻留集大小：" << endl;cin >> n;cout << "input the pages" << endl;for( int i = 1;i <= m;i++ )cin >> a[ i ];cout << endl;cout << "The result of FIFO:" << endl;FIFO( a,n,m );cout << endl;cout << "The result of LRU:" << endl;LRU( a,n,m );cout << endl;cout << "The result of OPT:" << endl;OPT( a,n,m );cout << endl;return 0;delete [] a;}七.结论此次C语言程序设计，我收获颇多，不仅巩固了书本上的知识，尤其是数据结构相关的知识点的回顾，例如指针链队列，头指针尾指针，以及队列结点的删除和添加等等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include <stdio.h>#include <stdlib.h>#include <conio.h>/*全局变量*/int mSIZE; /*物理块数*/int pSIZE; /*页面号引用串个数*/static int memery[10]={0}; /*物理块中的页号*/static int page[100]={0}; /*页面号引用串*/static int temp[100][10]={0}; /*辅助数组*//*置换算法函数*/void FIFO();void LRU();void OPT();/*辅助函数*/void print(unsigned int t);int main(){int i,k,code;printf(" ╔═══════════════╗\n");printf(" ║页面置换算法║\n");printf(" ╚═══════════════╝\n");printf("请输入物理块的个数(M<=10)：");scanf("%d",&mSIZE);printf("请输入页面号引用串的个数(P<=100)：");scanf("%d",&pSIZE);puts("请依次输入页面号引用串(连续输入，无需隔开)：");for(i=0;i<pSIZE;i++)scanf("%1d",&page[i]);do{puts("输入的页面号引用串为：");for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))printf("%d\n",page[i]);elseprintf("%d ",page[i]);}}printf("* * * * * * * * * * * * * * * * * * * * * * *\n");printf("* 请选择页面置换算法：\t\t\t *\n");printf("* ----------------------------------------- *\n");printf("* 1.先进先出(FIFO) 2.最近最久未使用(LRU) *\n");printf("* 3.最佳(OPT) 4.退出*\n");printf("* * * * * * * * * * * * * * * * * * * * * * *\n");printf("请选择操作：[ ]\b\b");scanf("%d",&code);switch(code){case 1:FIFO();break;case 2:LRU();break;case 3:OPT();break;case 4:exit(0);default:printf("输入错误，请重新输入：");}printf("按任意键重新选择置换算法：>>>");getch();system("cls");}while(code!=4);return 0;}void FIFO(){int memery[10]={0};int time[10]={0}; /*记录进入物理块的时间*/int i,j,k,m;int max=0; /*记录换出页*/int count=0; /*记录置换次数*//*前mSIZE个数直接放入*/for(i=0;i<mSIZE;i++){memery[i]=page[i];time[i]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){/*判断新页面号是否在物理块中*/for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;}if(k==mSIZE) /*如果不在物理块中*/{count++;/*计算换出页*/max=time[0]<time[1]?0:1;for(m=2;m<mSIZE;m++)if(time[m]<time[max])max=m;memery[max]=page[i];time[max]=i; /*记录该页进入物理块的时间*/for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}else{for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}}printf("\n\n利用先进先出(FIFO)算法的置换图\n\n");print(count);}/*最近最久未使用置换算法*/void LRU(){int memery[10]={0};int flag[10]={0}; /*记录页面的访问时间*/int i,j,k,m;int max=0; /*记录换出页*/int count=0; /*记录置换次数*//*前mSIZE个数直接放入*/for(i=0;i<mSIZE;i++){memery[i]=page[i];flag[i]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){/*判断新页面号是否在物理块中*/for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;elseflag[j]=i; /*刷新该页的访问时间*/}if(k==mSIZE) /*如果不在物理块中*/{count++;/*计算换出页*/max=flag[0]<flag[1]?0:1;for(m=2;m<mSIZE;m++)if(flag[m]<flag[max])max=m;memery[max]=page[i];flag[max]=i; /*记录该页的访问时间*/for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}else{for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}}printf("\n\n利用最近最久未使用(LRU)算法的置换图\n\n");print(count);}/*最佳置换算法*/void OPT(){int memery[10]={0};int next[10]={0}; /*记录下一次访问时间*/int i,j,k,l,m;int max; /*记录换出页*/int count=0; /*记录置换次数*//*前mSIZE个数直接放入*/for(i=0;i<mSIZE;i++){memery[i]=page[i];for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){/*判断新页面号是否在物理块中*/for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;}if(k==mSIZE) /*如果不在物理块中*/{count++;/*得到物理快中各页下一次访问时间*/for(m=0;m<mSIZE;m++){for(l=i+1;l<pSIZE;l++)if(memery[m]==page[l])break;next[m]=l;}/*计算换出页*/max=next[0]>=next[1]?0:1;for(m=2;m<mSIZE;m++)if(next[m]>next[max])max=m;/*下一次访问时间都为pSIZE,则置换物理块中第一个*/memery[max]=page[i];for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}else {for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}}printf("\n\n利用最佳置换算法(OPT)算法的置换图\n\n");print(count);}void print(unsigned int t){int i,j,k,l;int flag;for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))printf("%d\n",page[i]);elseprintf("%d ",page[i]);}for(j=0;j<mSIZE;j++){for(i=20*k;(i<mSIZE+20*k)&&(i<pSIZE);i++){if(i>=j)printf(" |%d|",temp[i][j]);elseprintf(" | |");}for(i=mSIZE+20*k;(i<pSIZE)&&(i<20*(k+1));i++){for(flag=0,l=0;l<mSIZE;l++)if(temp[i][l]==temp[i-1][l])flag++;if(flag==mSIZE)/*页面在物理块中*/printf(" ");elseprintf(" |%d|",temp[i][j]);}/*每行显示20个*/if(i%20==0)continue;printf("\n");}}printf("----------------------------------------\n");printf("缺页次数：%d\t\t",t+mSIZE);printf("缺页率：%d/%d\n",t+mSIZE,pSIZE);printf("置换次数：%d\t\t",t);printf("访问命中率：%d%%\n",(pSIZE-(t+mSIZE))*100/pSIZE);printf("----------------------------------------\n");}。