操作系统课程设计-页面置换算法C语言

合集下载

操作系统课设页面置换算法

目录一、课程设计目的及要求 (1)二、相关知识 (1)三、题目分析 (2)四、概要设计 (3)五、代码及流程 (3)六、运行结果 (7)七、设计心得 (8)八、参考文献 (9)一、课程设计目的及要求页面置换算法实验目的：深入掌握内存调度算法的概念原理和实现方法。

设计要求：编写程序实现：1）先进先出页面置换算法（FIFO）2）最近最久未使用页面置换算法（LRU）3）最佳置换页面置换算法（OPT）演示页面置换的三种算法。

二、相关知识2.1 先进先出（FIFO）算法这是最早出现的置换算法。

该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

该算法实现简单，只需把一个进程已调入内存的页面，按照先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总指向最老的页面。

但该算法与进程实际运行的规律不相适应，因为在进程中，有些页面经常被访问，比如，含有全局变量、常用函数、例程等的页面，FIFO算法并不能保证这些页面不被淘汰。

2.2 最近最久未使用（LRU）算法FIFO置换算法性能之所以较差，是因为它所依据的条件是各个页面调入内存的时间，而页面调入的先后并不能反映页面的使用情况。

最近最久未使用（LRU）的页面置换算法，是根据页面调入内存后的使用情况进行决策的。

由于无法预测各页将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU置换算法是选择最近最久未使用的页面予以淘汰。

该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t，当须淘汰一个页面时，选择现有页面中其t值最大的，即最近最久未使用的页面予以淘汰。

2.3 最佳（Optimal）算法最佳置换算法是由Belady于1966年提出的一种理论上的算法。

其所选择的被淘汰的页面，将是以后永不使用的，或是在最长（未来）时间内不再被访问的页面。

采用最佳置换算法，通常可保证获得最低的缺页率。

但由于人们目前还无法预知一个进程在内存的若干个页面中，哪一个页面是将来最长时间内不再访问的，因而该算法时无法实现的，但可以利用该算法评价其他算法。

页面置换算法课程设计

页面置换算法课程设计一、教学目标本章节的教学目标分为三个维度：知识目标、技能目标和情感态度价值观目标。

1.知识目标：使学生掌握页面置换算法的概念、原理和常见的算法，如FIFO、LRU、LFU 等。

2.技能目标：培养学生运用页面置换算法解决实际问题的能力，能够分析算法优缺点，并根据场景选择合适的算法。

3.情感态度价值观目标：培养学生对计算机科学领域的兴趣，激发学生探索和创新的精神，使其认识到算法在现代社会中的重要性。

二、教学内容本章节的教学内容主要包括以下几个部分：1.页面置换算法的概念和背景知识，如虚拟存储器、分页系统等。

2.常见页面置换算法的原理和实现，如 FIFO、LRU、LFU 等。

3.页面置换算法的性能分析，包括优缺点、适用场景等。

4.结合实际案例，让学生了解页面置换算法在操作系统中的应用。

三、教学方法为了提高教学效果，本章节将采用多种教学方法：1.讲授法：用于讲解页面置换算法的概念、原理和性能分析。

2.案例分析法：通过分析实际案例，使学生了解页面置换算法在操作系统中的应用。

3.实验法：安排实验课，让学生动手实现页面置换算法，提高其实际操作能力。

4.讨论法：学生分组讨论，比较不同页面置换算法的优缺点，培养学生独立思考和团队协作的能力。

四、教学资源为了支持教学内容和教学方法的实施，我们将准备以下教学资源：1.教材：《操作系统原理与应用》等相关教材，提供理论知识基础。

2.参考书：提供 additional references for students who want to deepentheir understanding of the subject.3.多媒体资料：制作PPT课件，生动展示页面置换算法的原理和应用。

4.实验设备：提供计算机及相关设备，让学生进行实验操作。

五、教学评估本章节的评估方式包括以下几个方面：1.平时表现：通过课堂参与、提问、讨论等环节，评估学生的学习态度和积极性。

页面置换-操作系统课程设计

页面置换算法模拟1、设计目的通过请求页式管理方式中页面置换算法的模拟设计，了解虚拟存储的特点，掌握请求页式存储管理中的页面置换算法。

2、任务及要求2.1 设计任务模拟实现先进先出算法（FIFO）、最近最少使用算法（LRU）、最优页置换算法（OPT），并计算命中率。

2.2 设计要求2.2.1 首先用随机数生成函数产生“指令”序列，然后将指令序列变换成相应的页地址流，再计算不同算法下的命中率。

2.2.2 通过随机数产生一个指令序列，共产生400条。

其中50%的指令是顺序执行的，且25%的指令分布在前半部分地址空间，25%的指令分布在后半部分地址空间。

2.2.3 将指令地址流变换成页地址流2.2.4 循环运行，使用户内存容量从4到40,。

计算每个内存容量下不同页面置换算法的命中率。

3、算法及数据结构3.1算法的总体思想（流程）struct Pro{int num,time;};int a[total_instruction];int page[N];//调用函数int Search(int e,Pro *page1 ){Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++){if(e==page[i].num)return i;}return -1;}void Input(Pro p[total_instruction]){int m,i,m1,m2;srand((unsigned int )time(NULL));m=rand()%400;for(i=0;i<total_instruction;) //产生指令队列{if(m<0||m>399){printf("When i==%d,Error,m==%d\n",i,m);exit(0);}a[i]=m; //任选一指令访问点ma[i+1]=a[i]+1;a[i+2]=a[i]+2; //顺序执行两条指令m1=rand( )%m; //执行前地址指令m1a[i+3]=m1;a[i+4]=m1+1;a[i+5]=m1 + 2;//顺序执行两条指令m2 = rand()%(157-m1)+m1+3;a[i+6]=m2;if( (m2+2) > 159 ){a[i+7] = m2+1;i +=8;}else{a[i+7] = m2+1;a[i+8] = m2+2;i = i+9;}m = rand()%m2;}//forfor(i=0;i<total_instruction;i++) //将指令序列变换成页地址流{p[i].num=a[i]/10;p[i].time = 0;}}3.2先进先出算法（FIFO）模块3.2.1 功能根据页地址流，采用先进先出的算法进行页面置换。

c语言实现页面置换

#include "stdio.h"#include "stdlib.h"#define true 1#define false 0int wang;/*是否有元素*/int have(int a[],int t){int i=0,j=0;for(j=0;j<4;j++){if(a[j]==t){i=1; /*有元素*/break;}}return i;}/*先进先出页面置换算法*/void FIFO(int num[]){int i,j,k;int a[4]={-1,-1,-1,-1} ;for(i=0,j=0;i<20;i++){if(j<4){if(have(a,num[i])==0) a[j++]=num[i];}else{if(have(a,num[i])==0) {for(j=1;j<4;j++) a[j-1]=a[j]; a[3]=num[i];}}for(k=0;k<4;k++)printf(" %2d",a[k]); printf(" \n");}}/*最近最久未使用*/void LRU(int num[]){int i,j,k,temp;int a[4]={-1,-1,-1,-1} ;for(i=0;i<20;i++){if(i==0)a[0]=num[0];else{for(j=0;j<4;j++){if(a[j]==num[i]) break;}for(k=j;k>0;k--){a[k]=a[k-1];}a[0]=num[i];}for(k=0;k<4;k++)printf(" %2d",a[k]); printf(" \n");}}/*选择排序*/void SelectSort(int r[],int n){int i,j,temp;for(i=0;i<n;i++){for(j=i+1;j<n;j++) /*不考虑后面元素，可视从j往前的数据都是排好的*/ {if(r[i]>r[j])/*如果当前元素r[j]比索引指向的元素r[i]小，换位*/ {temp=r[i];r[i]=r[j];r[j]=temp;}}}}/*返回要置换的位置*/int del(int a[],int num[],int n){int i,j;int s[4]={0,0,0,0};int t[4]={0,0,0,0};for(i=0;i<4;i++){for(j=n;j<20;j++){if(a[i]==num[j]){s[i]=j;t[i]=j;break;}}if(j==20){ s[i]=20;t[i]=20;}}SelectSort(s,4);for(i=0;i<4;i++){if(t[i]==s[3])break;}return i;}/*最佳置换算法*/void Optimal(int num[]){int i,j,k,temp;int a[4]={-1,-1,-1,-1} ;for(i=0,j=0;i<20;i++){if(j<4){if(have(a,num[i])==0) a[j++]=num[i];}else{if(have(a,num[i])==0) {temp=del(a,num,i); a[temp]=num[i];}}for(k=0;k<4;k++)printf(" %2d",a[k]); printf(" \n");}}void main(){loop: /* 循环 */{char ch;int i;int num[20];/*初始化页面调用数组*/for(i=0;i<20;i++){num[i]=rand()%10;printf(" %d",num[i]);}printf("\n");printf("----------------------------------\n");printf(" 1---FIFO;2---LRU;3---Optimal\n");printf("----------------------------------\n\n");printf("intput the NO. :");i=0;scanf("%d",&i);printf("\n [1] [2] [3] [4]\n");switch (i){case 1:FIFO(num);break;case 2:LRU(num); break;case 3:Optimal(num);break;default:printf("input wrong No.!!!");}printf("again?(y or n)\ninput:");loop_1:{ch=getch();if(ch=='y') /* y 再次输入 */goto loop;else if(ch=='n') /* n 退出 */exit(0);else /* 都不是提示输入错误 */{printf("\ninput wrong!again please!!!\ninput:"); goto loop_1;}}}}。

C语言实现页面置换算法

C语⾔实现页⾯置换算法本⽂实例为⼤家分享了C语⾔实现页⾯置换算法的具体代码，供⼤家参考，具体内容如下操作系统实验页⾯置换算法（FIFO、LRU、OPT）概念：1.最佳置换算法（OPT）（理想置换算法）：从主存中移出永远不再需要的页⾯；如⽆这样的页⾯存在，则选择最长时间不需要访问的页⾯。

于所选择的被淘汰页⾯将是以后永不使⽤的，或者是在最长时间内不再被访问的页⾯，这样可以保证获得最低的缺页率。

2.先进先出置换算法（FIFO）：是最简单的页⾯置换算法。

这种算法的基本思想是：当需要淘汰⼀个页⾯时，总是选择驻留主存时间最长的页⾯进⾏淘汰，即先进⼊主存的页⾯先淘汰。

其理由是：最早调⼊主存的页⾯不再被使⽤的可能性最⼤。

3．最近最久未使⽤（LRU）算法：这种算法的基本思想是：利⽤局部性原理，根据⼀个作业在执⾏过程中过去的页⾯访问历史来推测未来的⾏为。

它认为过去⼀段时间⾥不曾被访问过的页⾯，在最近的将来可能也不会再被访问。

所以，这种算法的实质是：当需要淘汰⼀个页⾯时，总是选择在最近⼀段时间内最久不⽤的页⾯予以淘汰。

题⽬：编写⼀个程序，实现本章所述的FIFO、LRU和最优页⾯置换算法。

⾸先，⽣成⼀个随机的页⾯引⽤串，其中页码范围为0-9.将这个随机页⾯引⽤串应⽤到每个算法，并记录每个算法引起的缺页错误的数量。

实现置换算法，⼀遍页⾯帧的数量可以从1~7。

#include <stdio.h>#include <stdlib.h>#include <time.h>int numbers[20]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};//本地数据，与课本⼀致，⽅便测试int nums=0;//输⼊栈的个数，为了⽅便使⽤，int stack[20][7]={10};void begin();void randomnum();//⽤于产⽣随机数void init();//初始化void FIFO();//FIFO算法void LRU();//LRU算法void OPT();//最优页⾯置换算法（OPT）void print();//输出int main() {begin();FIFO();LRU();OPT();return 0;}void begin()//开始菜单界⾯{int i,j,k;printf("请输⼊页⾯帧的数量(1-7)：");scanf("%d",&nums);for(k=0;;k++){printf("是否使⽤随机数产⽣输⼊串（0：是，1：否）");scanf("%d",&j);if(j==0){randomnum();break;}else if(j==1){break;}else{printf("请输⼊正确的选择！\n");}}printf("页⾯引⽤串为：\n");for(i=0;i<20;i++){printf("%d ",numbers[i]);}printf("\n");init();}void randomnum()//如果需要使⽤随机数⽣成输⼊串，调⽤该函数{srand(time(0));//设置时间种⼦for(int i = 0; i < 20; i++) {numbers[i] = rand() % 10;//⽣成区间0`9的随机页⾯引⽤串}}void init()//⽤于每次初始化页⾯栈中内容，同时⽅便下⾯输出的处理{int i,j;for(i=0;i<20;i++)for(j=0;j<nums;j++)stack[i][j]=10;}void print()//输出各个算法的栈的内容{int i,j;for(i=0;i<nums;i++){for(j=0;j<20;j++){if(stack[j][i]==10)printf("* ");elseprintf("%d ",stack[j][i]);}printf("\n");}}void FIFO()//FIFO算法{init();int i,j=1,n=20,k,f,m;stack[0][0]=numbers[0];for(i=1;i<20;i++){f=0;for(m=0;m<nums;m++){stack[i][m]=stack[i-1][m];}for(k=0;k<nums;k++){if(stack[i][k]==numbers[i]){n--;f=1;break;}}if(f==0){stack[i][j]=numbers[i];j++;}if(j==nums)j=0;}printf("\n");printf("FIFO算法：\n");print();printf("缺页错误数⽬为：%d\n",n);}void LRU()//LRU算法{int i,j,m,k,sum=1;int sequence[7]={0};//记录序列init();stack[0][0]=numbers[0];sequence[0]=nums-1;for(i=1;i<nums;i++)//前半部分，页⾯空置的情况{for(j=0;j<nums;j++){stack[i][j]=stack[i-1][j];}for(j=0;j<nums;j++){if(sequence[j]==0){stack[i][j]=numbers[i];break;}}for(j=0;j<i;j++)//将之前的优先级序列都减1{sequence[j]--;}sequence[i]=nums-1;//最近使⽤的优先级列为最⾼sum++;}for(i=nums;i<20;i++)//页⾯不空，需要替换的情况{int f;f=0;for(j=0;j<nums;j++){stack[i][j]=stack[i-1][j];}for(j=0;j<nums;j++)//判断输⼊串中的数字，是否已经在栈中 {if(stack[i][j]==numbers[i]){f=1;k=j;break;}}if(f==0)//如果页⾯栈中没有，不相同{for(j=0;j<nums;j++)//找优先序列中为0的{if(sequence[j]==0){m=j;break;}}for(j=0;j<nums;j++){sequence[j]--;}sequence[m]=nums-1;stack[i][m]=numbers[i];sum++;}else//如果页⾯栈中有，替换优先级{if(sequence[k]==0)//优先级为最⼩优先序列的{for(j=0;j<nums;j++){sequence[j]--;}sequence[k]=nums-1;}else if(sequence[k]==nums-1)//优先级为最⼤优先序列的{//⽆需操作}else//优先级为中间优先序列的{for(j=0;j<nums;j++){if(sequence[k]<sequence[j]){sequence[j]--;}}sequence[k]=nums-1;}}}printf("\n");printf("LRU算法：\n");print();printf("缺页错误数⽬为：%d\n",sum);}void OPT()//OPT算法{int i,j,k,sum=1,f,q,max;int seq[7]={0};//记录序列init();stack[0][0]=numbers[0];seq[0]=nums-1;for(i=1;i<nums;i++)//前半部分，页⾯空置的情况{for(j=0;j<nums;j++){stack[i][j]=stack[i-1][j];}for(j=0;j<nums;j++){if(seq[j]==0){stack[i][j]=numbers[i];break;}}for(j=0;j<i;j++)//将之前的优先级序列都减1{seq[j]--;}seq[i]=nums-1;//最近使⽤的优先级列为最⾼sum++;}for(i=nums;i<20;i++)//后半部分，页⾯栈中没有空的时候情况{//k=nums-1;//最近的数字的优先级for(j=0;j<nums;j++)//前⾯的页⾯中内容赋值到新的新的页⾯中{stack[i][j]=stack[i-1][j];}for(j=0;j<nums;j++){f=0;if(stack[i][j]==numbers[i]){f=1;break;}}if(f==0)//页⾯中没有，需要替换的情况{for(q=0;q<nums;q++)//优先级序列中最⼤的就是最久未⽤的，有可能出现后⾯没有在⽤过的情况 {seq[q]=20;}for(j=0;j<nums;j++)//寻找新的优先级{for(q=i+1;q<20;q++){if(stack[i][j]==numbers[q]){seq[j]=q-i;break;}}}max=seq[0];k=0;for(q=0;q<nums;q++){if(seq[q]>max){max=seq[q];k=q;}}stack[i][k]=numbers[i];sum++;}else{//页⾯栈中有需要插⼊的数字，⽆需变化，替换的优先级也不需要变化 }}printf("\n");printf("OPT算法：\n");print();printf("缺页错误数⽬为：%d\n",sum);}运⾏结果截图：以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

实验报告页面置换算法(c语言实现)

实验三页面置换算法#include<iostream.h>#include <stdlib.h>#include <time.h>#include <stdio.h>#define L 20int M; struct Proi nt num,time;};I nput(int m,Pro p[L]){i nt i,j,c;c out<<"请输入实际页面走向长度L(15<=L<=20)：";d o{c in>>m;i f(m>20||m<15)cout<<"实际页面长度须在15～20之间;请重新输入L：";e lse break;}while(1);j=time(NULL);s rand(j);c out<<"输出随机数: ";f or(i=0;i<m;i++){p[i].num=rand( )%10+1;p[i].time=0;c out<<p[i].num<<" ";}c out<<endl;r eturn m;}v oid print(Pro *page1){P ro *page=new Pro[M];p age=page1;f or(int i=0;i<M;i++)i f(page[i].num==-1)c out<<" ";e lsec out<<page[i].num<<" ";c out<<"√"<<endl;}i nt Search(int e,Pro *page1 ){P ro *page=new Pro[M];p age=page1;f or(int i=0;i<M;i++) if(e==page[i].num) return i; r eturn -1;}i nt Max(Pro *page1){}i nt Count(Pro *page1,int i,int t,Pro p[L]){}i nt main(){i nt c;i nt m=0,t=0;f loat n=0;P ro p[L];c out<<"********************************************* "<<endl;c out<<" * 页式存储管理*"<<endl;c out<<"********************************************* "<<endl;c out<<"请输入可用内存页面数m(3～5): ";d o{c in>>M;i f(M>5||M<3)c out<<"内存块M须在3～5之间，请重新输入M：";e lse break;}while(1);m=Input(m,p);P ro *page=new Pro[M];c out<<"^-^欢迎进入操作系统界面^-^"<<endl;c out<<"1:FIFO页面置换"<<endl;c out<<"2:LRU页面置换"<<endl;c out<<"3:OPT页面置换"<<endl;c out<<"4:退出"<<endl;d o{c out<<"按1～4键操作："<<endl;c in>>c;s ystem("cls");f or(int i=0;i<M;i++){p age[i].num=-1;p age[i].time=m-1-i;}i=0;i f(c==1){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" FIFO算法页面置换情况如下: "<<endl;cout<<endl;c out<<"******************************************"<<endl;w hile(i<m){i f(Search(p[i].num,page)>=0) {cout<<p[i].num<<" "; p[i].numc out<<"不缺页"<<endl;i++;}e lse {i f(t==M)t=0;e lse{n++;p age[t].num=p[i].num;c out<<p[i].num<<" ";p rint(page);t++;i++;}}}c out<<"缺页次数："<<n<<" }i f(c==2){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" LRU算法页面置换情况如下: "<<endl;c out<<endl;c out<<"******************************************"<<endl;w hile(i<m){i nt a;t=Search(p[i].num,page);i f(t>=0){p age[t].time=0;for(a=0;a<M;a++)i f(a!=t)page[a].time++;cout<<p[i].num<<" ";c out<<"不缺页"<<endl;}e lse{n++; t=Max(page);page[t].num=p[i].num; page[t].time=0;cout<<p[i].num<<" ";p rint(page);f or(a=0;a<M;a++)i f(a!=t)page[a].time++;}i++;}c out<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}i f(c==3){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" OPT算法置换情况如下:"<<endl;c out<<endl;c out<<"******************************************"<<endl;w hile(i<m){i f(Search(p[i].num,page)>=0){c out<<p[i].num<<" ";c out<<"不缺页"<<endl;i++;}e lse{i nt a=0;f or(t=0;t<M;t++)i f(page[t].num==0)a++;if(a!=0) {i nt q=M;f or(t=0;t<M;t++)i f(page[t].num==0&&q>t)q=t;p age[q].num=p[i].num;n++;c out<<p[i].num<<" ";p rint(page);i++;}e lse{i nt temp=0,s;f or(t=0;t<M;t++)i f(temp<Count(page,i,t,p)){t emp=Count(page,i,t,p);s=t;}page[s].num=p[i].num;n++;c out<<p[i].num<<" ";p rint(page);i++;}}}c out<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}i f(c==4){c out<<" ^-^再见！^-^ "<<endl;}}while(c==1||c==2||c==3||c==4);r eturn 0;}结果：完成相关实验并且获得预期结果.。

烟台大学操作系统课程设计页面置换算法

烟台大学计算机与控制工程学院
计算机操作系统
课程设计报告
题目：页面置换算法
班级计165
姓名王承乾
学号 2
日期2018-7-3
指导教师翟一鸣
实验地点计算机与控制工程学院实验室
一、实验内容
页面置换算法：淘汰掉内存中的某些页为必须进入内存的页面腾出空间的策略。

最优算法（OPT）：从内存中移出以后不再使用的页面，如果没有这样的页面，则选择以后最长时间内不需要访问的页面。

先进先出算法（FIFO）：总是先淘汰那些驻留在内存时间最长的页面，即先进入内存的页面先被置换掉。

最近最久未使用算法（LRU）：当需要置换一页时，选择最近一段时间最久未使用的页面予以淘汰。

设计程序模拟先进先出（FIFO）置换算法，最佳（OPT）置换算法和最近最少用（LRU）置换算法的工作过程。

假设内存中分配给每个进程的最小物理块数为m，在进程运行过程中要访问的页面个数为n，页面访问序列为P1, … ,Pn，分别利用不同的页面置换算法调度进程的页面访问序列，给出页面访问序列的置换过程，计算每种算法缺页次数和缺页率。

程序的设计主要是测试先进先出FIFO，最佳置换OPT和最近最少用LRU页面置换算法的效率以及过程。

二、实验目的
使用系统函数以及c语言的相关语句实现页面置换的三个算法
三、实验环境
开发环境：Windows
编译环境：gcc，g++
开发软件：Codeblocks 16.01。

先进先出（FIFO）页面置换算法C语言实现、最近最久未使用（LRU）页面置换算法C语言实现

先进先出（FIFO）页⾯置换算法C语⾔实现、最近最久未使⽤（LRU）页⾯置换算法C语⾔实现1.实现效果2.实现源代码1 #include<iostream>2 #include<process.h>3 #include<stdlib.h>4 #include<ctime>5 #include<conio.h>6 #include<stdio.h>7 #include<string.h>8using namespace std;910#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")/*表格控制*/11#define bsize 4 //物理块⼤⼩12#define psize 16 //进程⼤⼩13void chushihua();//初始化函数14void ymzh();16void changeaddr(struct Page p[], int logaddr);17void dizhizhuanhuan();18void menu();19int wang();2021int yemianliu[32]={0};//全局变量数组,地址流22int p;23struct Page {24int pno;//页号25int flag;//标志位26int cno;//主存号27int modf;//修改位28int addr;//外存地址29 }Page; //全局变量p是⼀共有多少地址流3031 typedef struct pagel32 {33int num; /*记录页⾯号*/34int time; /*记录调⼊内存时间*/35 }Pagel; /*页⾯逻辑结构,⽅便算法实现*/3637 Pagel b[bsize]; /*内存单元数*/38int c[bsize][psize];/*保存内存当前的状态:缓冲区*/39int queue[100];/*记录调⼊队列*/40int k;/*调⼊队列计数变量*/41int phb[bsize]={0};//物理块标号42int pro[psize]={0};//进程序列号43int flag[bsize]={0};//进程等待次数(存放最久未被使⽤的进程标志)*/ 44int i=0,j=0;//i表⽰进程序列号,j表⽰物理块号*/45int m =-1,n =-1;//物理块空闲和进程是否相同判断标志*/46int mmax=-1, maxflag=0;//标记替换物理块进程下标*/47int count =0; //统计页⾯缺页次数4849void chushihua() //初始化函数50 {51int t;52 srand(time(0));//随机产⽣指令序列53 p=12+rand()%32;54 cout<<"地址流序列:";55 cout<<endl;56for(i=0; i<p; i++)57 {58 t=1+rand()%9;59 yemianliu[i]=t;//将随机产⽣的指令数存⼊页⾯流60 }61for (i=p-1;i>=0;i--)62 {63 cout<<yemianliu[i]<<"";64 }65 cout<<endl;66 }67void ymzh()68 {69 chushihua();70 yemianzhihuan();71 }7273void yemianzhihuan()74 {75int a;76 printf("----------------------------------\n");77 printf("☆☆欢迎使⽤分页模拟实验系统☆☆\n");78 printf("----------------------------------");79 printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");80 printf("☆☆1.进⼊硬件地址变换算法☆☆\n");81 printf("☆☆------------------------☆☆\n");82 printf("☆☆2.进⼊页⾯置换算法☆☆\n");83 printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");84 printf("请输⼊您的选择:");85switch(a)86 {87case1:88 ymzh();89break;90case2:91 wang();92break;93default:94 cout<<"输⼊有误,请重新输⼊!"<<endl;95break;96 }97 }98100int j=logaddr/64;//对应的块号101int k=logaddr%64; //对应的偏移量102int flag=0;103int addr;104for(int i=0;i<8;i++)105 {106if(p[i].pno==j)//找到对应的页号107 {108if(p[i].flag==1)//页⾯标志为1109 {110 addr=p[i].cno*64+k;111 cout<<"物理地址为:"<<addr<<endl;112 cout<<"详细信息:"<<"\t页⾯号:"<<p[i].pno<<"\t 主存号："<<p[i].cno<<"\t偏移量:"<<k<<endl; 113 flag=1;114break;115 }116 }117 }118119if(flag==0)120 cout<<"该页不在主存,产⽣缺页中断"<<endl;121 }122123void dizhizhuanhuan()124 {125int a;126int ins;//指令逻辑地址127struct Page p[8];128 p[0].pno=0;p[0].flag=1;p[0].cno=5;p[0].modf=1;p[0].addr=011;129 p[1].pno=1;p[1].flag=1;p[1].cno=8;p[1].modf=1;p[1].addr=012;130 p[2].pno=2;p[2].flag=1;p[2].cno=9;p[2].modf=0;p[2].addr=013;131 p[3].pno=3;p[3].flag=1;p[3].cno=10;p[3].modf=0;p[3].addr=015;132 p[4].pno=4;p[4].flag=0;p[4].addr=017;133 p[5].pno=5;p[5].flag=0;p[5].addr=025;134 p[6].pno=6;p[6].flag=0;p[6].addr=212;135 p[7].pno=7;p[7].flag=0;p[7].addr=213;136 printf("\t\t\t--------------------------------\n");137 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");138 printf("\t\t\t---------------------------------\n");139 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");140 printf("\t\t\t☆☆1.输⼊指令☆☆\n");141 printf("\t\t\t☆☆------------------------☆☆\n");142 printf("\t\t\t☆☆2.进⼊页⾯置换算法☆☆\n");143 printf("\t\t\t☆☆------------------------☆☆\n");144 printf("\t\t\t☆☆0.EXIT ☆☆\n");145 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");146while(a!=0)147 {148 cout<<endl<<"请输⼊您的选择:";149 cin>>a;150151 cout<<"页号"<<"标记位"<<"外存地址"<<"主存号"<<endl;152for(int i=0;i<8;i++)153 {154 cout<<p[i].pno<<"\t"<<p[i].flag<<"\t"<<p[i].addr<<"\t";155if(p[i].flag)156 cout<<p[i].cno;157 cout<<endl;158 }159160switch(a)161 {162case0:printf("\t\t\t再见!\t\t\t\n"); break;163case1:164 cout<<"请输⼊指令的逻辑地址:";165 cin>>ins;166 changeaddr(p, ins);break;167case2: system("CLS"); a=wang();break;168default:cout<<"输⼊有误,请重新输⼊!"<<endl;break;169 }170 }171 }172173void menu()174 {175int a;176 printf("\t\t\t--------------------------------\n");177 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");178 printf("\t\t\t---------------------------------\n");179 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");180 printf("\t\t\t☆☆1.输⼊指令☆☆\n");181 printf("\t\t\t☆☆------------------------☆☆\n");182 printf("\t\t\t☆☆2.进⼊页⾯置换算法☆☆\n");184 printf("\t\t\t☆☆0.EXIT ☆☆\n");185 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n"); 186 printf("请选择所要执⾏的操作:");187 scanf("%d",&a);188switch(a)189 {190case0: printf("\t\t\t-再见!-\t\t\t\n");break;191case1: dizhizhuanhuan (); break;192case2: wang (); break;193default:cout<<"输⼊有误,请重新输⼊!"<<endl;break; 194 }195 }196int main()197 {198 menu();199 }200201//****************随机产⽣序列号函数202int* build()203 {204 printf("随机产⽣⼀个进程序列号为:\n");205int i=0;206for(i=0; i<psize; i++)207 {208 pro[i]=10*rand()/(RAND_MAX+1)+1;209 printf("%d ", pro[i]);210 }211 printf("\n");212return(pro);213 }214215//***************************************查找空闲物理块216int searchpb()217 {218for (j=0;j<bsize; j++)219 {220if(phb[j] == 0)221 {222 m=j;223return m;224break;225 }226 }227return -1;228 }229//************************************查找相同进程230int searchpro()231 {232for(j=0;j< bsize;j++)233 {234if(phb[j] =pro[i])235 {236 n=j;237return j;238 }239 }240return -1;241 }242243//*************************初始化内存244void empty()245 {246for(i=0;i<bsize;i++)247 phb[i]=0;248 count=0; //计数器置零249 } //******先进先出页⾯置换算法250void FIFO()251 {252for( i=0; i<psize; i++)253 {254// m=searchpb();255// n=searchpro();256//找到第⼀个空闲的物理快257for(j=0;j<bsize;j++) {258if(phb[j] == 0){259 m=j;260break;261 }262 }263//找与进程相同的标号264for(j=0;j<bsize;j++) {265if(phb[j] == pro[i]){266 n=j;268 }269270//找flag值最⼤的271for(j=0;j<bsize;j++)272 {273if(flag[j]>maxflag)274 {275 maxflag = flag[j];276 mmax = j;277 }278 }279280if(n == -1)//不存在相同进程281 {282if(m != -1)//存在空闲物理块283 {284 phb[m]=pro[i];//进程号填⼊该空闲物理块285// count++;286 flag[m]=0;287for (j=0;j<=m; j++)288 {289 flag[j]++;290 }291 m=-1;292 }293else//不存在空闲物理块294 {295 phb[mmax] =pro[i];296 flag[mmax] =0;297for (j=0;j<bsize;j++)298 {299 flag[j]++;300 }301 mmax = -1;302 maxflag = 0;303 count++;304 }305 }306else//存在相同的进程307 {308 phb[n] = pro[i];309for(j=0;j<bsize;j++)310 {311 flag[j]++;312 }313 n=-1;314 }315for(j=0;j < bsize;j++)316 {317 printf("%d ", phb[j]);318 }319 printf("\n");320 }321 printf("缺页次数为:%d\n",count);322 printf("缺页率 :%16. 6f",(float)count/psize);323 printf("\n");324 }325/*初始化内存单元、缓冲区*/326void Init(Pagel *b,int c[bsize][psize])327 {328int i,j;329for (i=0;i<psize;i++)330 {331 b[i].num=-1;332 b[i].time=psize-i-1;333 }334for(i=0;i<bsize;i++)335for(j=0;j<psize;j++)336 c[i][j]=-1;337 }338/*取得在内存中停留最久的页⾯,默认状态下为最早调⼊的页⾯*/ 339int GetMax(Pagel *b)340 {341int i;342int max=-1;343int tag=0;344for(i=0;i<bsize;i++)345 {346if(b[i].time>max)347 {348 max=b[i].time;349 tag= i;350 }353 }354355/*判断页⾯是否已在内存中*/356int Equation(int fold, Pagel *b)357 {358int i;359for(i=0;i<bsize;i++)360 {361if(fold==b[i]. num)362return i;363 }364return -1;365 }366/*LRU核⼼部分*/367void Lruu(int fold, Pagel *b)368 {369int i;370int val;371 val=Equation(fold, b);372if (val>=0)373 {374 b[val].time=0;375for(i=0;i<bsize;i++)376if (i!=val)377 b[i].time++;378 }379else380 {381 queue[++k]=fold;/*记录调⼊页⾯*/382 val=GetMax(b);383 b[val].num=fold;384 b[val].time=0;385for (i=0;i<bsize;i++){386387// URLcount++;388if (i!=val)389 b[i].time++;390 }391 }392 }393394void LRU()395 {396int i,j;397 k=0;398 Init(b, c);399for(i=0; i<psize; i++)400 {401 Lruu(pro[i],b);402 c[0][i]=pro[i];403/*记录当前的内存单元中的页⾯*/404for(j=0;j<bsize;j++)405 c[j][i]=b[j].num;406 }407408/*结果输出*/409 printf("内存状态为:\n");410 Myprintf;411for(j=0;j<psize;j++)412 printf("|%2d", pro[j]);413 printf("|\n");414 Myprintf;415416for(i=0;i<bsize;i++)417 {418for(j=0; j<psize; j++)419 {420if(c[i][j]==-1)421 printf("|%2c",32);422else423 printf("|%2d",c[i][j]);424 }425 printf("|\n");426 }427428 Myprintf;429// printf("\n调⼊队列为:");430// for(i=0;i<k;i++)431// printf("%3d", queue[i]);432433 printf("\n缺页次数为:%6d\n 缺页率 :%16. 6f", k+1,(float)(k+1)/psize); 434 }437int wang()438 {439int sel;440do{441 printf("\t\t\t--------------------------------\n");442 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");443 printf("\t\t\t---------------------------------\n");444 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");445 printf("\t\t\t☆☆虚拟内存☆☆\n");446 printf("\t\t\t☆☆------------------------☆☆\n");447 printf("\t\t\t☆☆1.产⽣随机序列☆☆\n");448 printf("\t\t\t☆☆------------------------☆☆\n");449 printf("\t\t\t☆☆2.最近最久未使⽤☆☆\n");450 printf("\t\t\t☆☆------------------------☆☆\n");451 printf("\t\t\t☆☆3.先进先出☆☆\n");452 printf("\t\t\t☆☆------------------------☆☆\n");453 printf("\t\t\t☆☆0.退出☆☆\n");454 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");455 printf("请选择所要执⾏的操作:");456 scanf("%d",&sel);457switch(sel)458 {459case0: printf("\t\t\t再见!t\t\t\n"); break;460case1: build(); break;461case2: printf("最近最久未使⽤\n"); LRU();empty(); printf("\n");break; 462case3: printf("先进先出算法\n"); FIFO();empty();printf("\n");break; 463default:printf("请输⼊正确的选项号!");printf("\n\n");break;464 }465 }while(sel !=0 );466return sel;467 }。

lru页面置换算法实验c语言总结

LRU页面置换算法实验C语言总结1.引言在计算机科学中，页面置换算法是解决主存容量有限的情况下，如何有效地管理页面（或称为内存块）的一种重要方法。

L RU（L ea st Re ce nt ly Us e d）页面置换算法是其中一种经典的策略，通过淘汰最久未使用的页面来提高内存的利用率。

本文将总结使用C语言实现L RU页面置换算法的相关实验。

2.算法原理L R U页面置换算法的核心思想是：最近被访问的页面可能在未来继续被访问，而最久未被使用的页面可能在未来也不再被访问。

基于这一思想，L R U算法维护一个页面访问的时间顺序链表，每次发生页面置换时，选择链表头部（即最久未使用）的页面进行淘汰。

3.实验设计本次实验旨在使用C语言实现LR U页面置换算法，并通过模拟页面访问的过程来验证算法的正确性。

具体设计如下：3.1数据结构为了实现LR U算法，我们需要定义几个关键的数据结构：3.1.1页面节点结构t y pe de fs tr uc tP age{i n tp ag eI D;//页面I Ds t ru ct Pa ge*n ex t;//下一个节点指针s t ru ct Pa ge*p re v;//上一个节点指针}P ag e;3.1.2内存块结构t y pe de fs tr uc tM emo r y{i n tc ap ac it y;//内存块容量i n ts iz e;//当前存储的页面数量P a ge*h ea d;//内存块链表头指针P a ge*t ai l;//内存块链表尾指针}M em or y;3.2实验步骤本次实验主要包括以下几个步骤：3.2.1初始化内存块根据实际需求，设置内存块的容量，并初始化链表头指针和尾指针。

3.2.2页面置换每次发生页面访问时，检查访问的页面是否已经在内存块中。

如果在，将该页面移动到链表尾部；如果不在，执行页面置换。

3.2.3页面淘汰当内存块已满时，选择链表头部的页面进行淘汰，将新访问的页面加入链表尾部。

操作系统课程设计页面置换算法C语言word文档良心出品

页面置换算法一•题目要求：通过实现页面置换算法的FIFO 和LRU 两种算法，理解进程运行时系统是怎样选择换出页面的，对于两种不同的算法各自的优缺点是哪些。

要求设计主界面以灵活选择某算法，且以下算法都要实现最佳置换算法(OPT):将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。

先进先出算法(FIFO):淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

最近最久未使用算法(LRU):淘汰最近最久未被使用的页面。

最不经常使用算法(LFU)1、编写算法，实现页面置换算法 FIFO 、LRU2、针对内存地址引用串，运行页面置换算法进行页面置换;3、算法所需的各种参数由输入产生(手工输入或者随机数产生)；4、输出内存驻留的页面集合，页错误次数以及页错误率; 四. 相关知识：1虚拟存储器的引入：局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。

2. 虚拟存储器的定义：虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。

3. 虚拟存储器的实现方式：分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。

请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。

4. 页面分配：平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。

按比例分配算法，根据进程的大小按比例分配物理块。

考虑优先的分配算法，把内存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。

1) 2) 3) 4)二•实验目的：1、用C 语言编写OPT 、FIFO 、LRU , LFU 四种置换算法。

操作系统课程设计：lru页面置换算法

操作系统功能模拟设计实验题目： lru置换算法（C编写）学生姓名：计号学号： 1104032022专业：网络工程班级：11网络工程二班实验题目LRU页面调度算法处理缺页中断一、实验目的：了解和掌握寄存器分配和内存分配的有关技术二、实验内容（1）首先对LRU页面调度算法原理进行深刻的理解和掌握；（2）选择一种熟悉的编程语言来实现对一组访问序列进行内部的cache更新；（3）根据LRU页面调度算法算法的要求设计相应的数据结构，如：记录访问序列的数组、模拟内存cache的数组等等；（4）显示每个访问数进入cache的操作并显示出每次访问后内存中序列的状态。

三、实验环境Windows系统，c语言四、实验主要步骤（包括使用的数据结构的说明）1、初始化及使用数据结构开始的阶段，产生随机的访问序列，并用了结构体：struct page{int pageframe[10]; // 表示页表int flag; //标记是否有页面置换int length; //用来访问序列的长度int page_count; //页框的数目int page_serial[20]; //存取随机产生的访问序列组int count; //用来标识页框是否被装满int k; //用于记录访问页表的指针int pagetime[10]; //用来记录页框里面的数被访问的过后到再一次被访问所经历的的时间}p;并初始化这些量;void init(){ //初始化所有页表int i;p.flag=0;for(i=0;i<10;i++){p.pageframe[i]=-1;p.pagetime[i]=0;}for(i=0;i<20;i++){p.page_serial[i]=-1;}}2、LRU页面调度算法原理LRU页面调度算法是对要访问cache的访问序列进行更新的，当页表还是空的时候，进来要访问的页如果页表里面有的话，就对它的访问记录加一，如果也表里面没有切页表么有填满，就像页表里面添加。

【操作系统】页面置换算法（最佳置换算法）（C语言实现）

【操作系统】页⾯置换算法（最佳置换算法）（C语⾔实现）【操作系统】页⾯置换算法（最佳置换算法）（C语⾔实现）（编码⽔平较菜，写博客也只是为了个⼈知识的总结和督促⾃⼰学习，如果有错误，希望可以指出）1.页⾯置换算法：在地址映射过程中，若在页⾯中发现所要访问的页⾯不在内存中，则产⽣缺页中断。

当发⽣缺页中断时，如果操作系统内存中没有空闲页⾯，则操作系统必须在内存选择⼀个页⾯将其移出内存，以便为即将调⼊的页⾯让出空间。

⽽⽤来选择淘汰哪⼀页的规则叫做页⾯置换算法。

⼀个好的页⾯置换算法，应具有较低的页⾯更换频率。

从理论上讲，应该保留最近重复访问的页⾯，将以后都不再访问或者很长时间内不再访问的页⾯调出。

----百度百科2.具体的页⾯置换算法：2.1 最佳置换算法：⼀个进程在内存的若⼲个页⾯中，哪⼀个页⾯是未来最长时间内不再被访问的，那么如果发⽣缺页中断时，就将该页⾯换出，以便存放后⾯调⼊内存中的页⾯。

1.这是计算机操作系统（第四版）中的⼀个例⼦。

系统⾸先为进程分配了三个物理块。

上⾯⼀排数字是作业号。

在转满三个物理块后，要访问2号作业，2号作业不在内存，所以会发⽣缺页中断，然后系统需要将2号作业调⼊内存，但是此时物理块已经装满。

2.依据最佳置换算法，会将7号页换出（0号页在2号页后第1个就会被访问，1号页在2号页后第10个会被访问，7号页在2号页后第14个会被访问，7号页在已经装⼊内存的作业中是未来最长时间不会被访问的，所以换出7号页）。

3.后⾯依次类推。

2.2 先进先出算法：如果发⽣缺页中断，需要换出⼀个页⾯的时候，总是选择最早进⼊内存的页⾯，即选择在内存中驻留时间最久的页⾯进⾏换出。

有点不清楚。

就是每次发⽣缺页就将最早进⼊内存的页⾯换出，然后将刚调⼊的页⾯换⼊该物理块。

2.3 最近最久未使⽤（LRU）置换算法：LRU算法是缺页中断发⽣时选择最久未使⽤的页⾯进⾏换出。

这个算法其实也很好判断。

分享⼀个⼩技巧。

内存分配了k个物理块，发⽣缺页中断将要往内存调⼊某个页⾯的时候，在该页⾯往前⾯数K个物理块最前⾯的那个就会是要换出的，因为该页⾯最长时间未被使⽤过。

页面置换算法c语言fifo

页面置换算法C语言FIFO第一部分：介绍页面置换算法页面置换算法是操作系统中用于管理内存的一种重要算法，其目的是在物理内存不足时选择合适的页面进行替换，以保证系统的正常运行。

本部分将简要介绍页面置换算法的基本概念和作用。

1. 页面置换算法概述：页面置换算法是解决虚拟内存管理中的一个关键问题，即在有限的物理内存中如何有效地管理大量的进程和数据。

FIFO（First-In-First-Out）是其中一种经典的页面置换算法，它按照页面进入内存的先后顺序进行置换。

2. FIFO算法原理：FIFO算法采用队列的数据结构，将最早进入内存的页面视为队列的队首，最后进入的页面视为队尾。

当需要置换页面时，选择队首的页面进行替换。

这种方式保持了页面进入内存的顺序，但可能导致"Belady异常"现象。

第二部分：FIFO算法的C语言实现1. FIFO算法的基本实现：在C语言中，可以使用数组或链表来模拟队列结构，实现FIFO算法。

定义一个队列数据结构，包括队列的大小、队首和队尾指针等成员。

通过数组或链表实现入队和出队操作，完成FIFO算法的基本功能。

2. C语言代码示例：以下是一个简单的FIFO算法的C语言实现示例：c#include <stdio.h>define MAX_SIZE 10int fifo_queue[MAX_SIZE];int front = -1, rear = -1;入队操作void enqueue(int page) {if (rear == MAX_SIZE - 1) {printf("队列已满，无法入队\n");return;}if (front == -1) {front = 0;}rear++;fifo_queue[rear] = page;}出队操作void dequeue() {if (front == -1) {printf("队列为空，无法出队\n");return;}printf("出队的页面：%d\n", fifo_queue[front]); if (front == rear) {front = rear = -1;} else {front++;}}第三部分：FIFO算法的应用场景1. 操作系统内存管理：FIFO算法常用于操作系统的虚拟内存管理中，用于页面的置换。

(完整word版)实验八页面置换模拟程序设计C语言实验

实验八页面置换模拟程序设计一、【实验目的】加深对请求页式存储管理实现原理的理解，掌握页面置换算法。

二、【实验内容】1．假设分给一作业的内存块数为4，每个页面中可存放10条指令。

2．用C语言设计一个程序,模拟一作业的执行过程。

设该作业共有320条指令,即它的地址空间为32页，目前它的所有页面都还未调入内存。

在模拟过程中，如果所访问的指令已经在内存，则显示其物理地址，并转下一条指令。

如果所访问的指令尚未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存.如果4个内存块中均已装入该作业的虚页面，则需进行页面置换。

最后显示其物理地址，并转下一条指令。

在所有320条指令执行完毕后,请计算并显示作业运行过程中发生的缺页率。

3．置换算法：请分别考虑OPT、FIFO和LRU算法.4．作业中指令的访问次序要求按下述原则生成：50%的指令是顺序执行的.25％的指令是均匀分布在前地址(即低地址）部分。

25％的指令是均匀分布在后地址（即高地址）部分。

具体的实施办法是：①在［0，319］之间随机选取一条起始执行指令，其序号为m;②顺序执行下一条指令，即序号为m+1的指令；③通过随机数,跳转到前地址部分［0,m-1］中的某条指令处，其序号为m1；④顺序执行下一条指令，即序号为m1+1的指令；⑤通过随机数,跳转到后地址部分［m1+2，319]中的某条指令处,其序号为m2；⑥顺序执行下一条指令,即序号为m2+1的指令；⑦重复“跳转到前地址部分、顺序执行、跳转到后地址部分、顺序执行”的过程，直至执行完全部320条指令。

5。

随机数产生办法，Linux或UNIX系统提供函数strand(）和rand(）,分别进行初始化和产生随机数。

例如：strand (）; 语句可初始化一个随机数；a[0］=10＊rand（)/65535＊319+1; a［1］=10*rand()/65535*a[0]; 语句可用来产生a［0］与a［1］中的随机数。

操作系统课程设计页面置换算法

《操作系统》实验报告实验题目:班级：学号：姓名：实验日期：报告日期：成绩：实验内容简要描述1、实验目的（1）掌握先进先出页面置换算法；（2）掌握最近最久未使用页面置换算法；（3）掌握改进的CLOCK页面置换算法，了解其他页面置换算法；（4）熟悉C/C++或其他语言编程。

2、实验要求要求掌握C/C++语言进行编码，掌握页面缺页率的算法和基本思想，理解先进先出，最近最久未使用页面置换算法的，计算并记录缺页率。

根据实验数据撰写实验报告3、实验内容编写程序，设置不同的页面数，使用不同的页面替换策略算法进行模拟页面替换。

先进先出，最近最久未使用页面置换算法等，并计算缺页率。

4、实验环境1．PC微机2．Windows 操作系统3．C/C++或其他语言开发环境实验体会通过这次实验我学到了C/C++语言进行编码，以及页面缺页率的算法和基本思想，和页面置换算法的基本知识，发现了自己的一些不足，对今后编写C/C++语言提供了帮助。

附件：源程序[包括截图]#include<conio.h>#include<stdio.h>#include<dos.h>#include<stdlib.h>#include<math.h>#include<time.h>int add[256],page[256];int k,j,ram,t;float rate;struct s1{ int page; int free; int tag;}fifo[33],opt[33],lru[33];struct s2{ int time;};int random(int x){ return rand() % x;}void address();int random(int x);float FIFO(int ram);float OPT(int ram);float LRU(int ram);void main(){ int i,p[256]; address(); srand(time(0));for(k=1;k<=8;){ printf("the size of the page is %d k\n",k);printf("the page number is ...\n");for(i=0;i<256;i++){ p[i]=add[i]/(k*1024); printf("%d ",p[i]);}j=0;for(i=0;i<256;i++){ while(p[i]==p[i+1]) i++; page[j]=p[i]; j++;}printf("\nafter connect the same pages the page num is:\n"); for(i=0;i<j;i++)printf("%d ",page[i]);printf("\n");getch();for(ram=1;ram<=32;ram++){ if (ram==10)getch();printf("\nblock=%d pages=%d,absent rate:",ram,j);printf("FIFO=%0.2f%%",FIFO(ram));printf("LRU=%0.2f%%",LRU(ram));printf("OPT=%0.2f%%",OPT(ram));}k=k*2; getch();}}void address(){ int i; add[0]=1000;for(i=1;i<=255;i++){int x=random(1024);if((x>=0)&&(x<512))add[i]=add[i-1]+1;if((x>=512)&&(x<768))add[i]=random(add[i-1]-1)+1;if((x>=768)&&(x<1024))add[i]=add[i-1]+random(30*1024-add[i-1]-1)+1; }}float FIFO(int ram) /{ int absent=0,t=0,i,z,l,yn;for(i=0;i<ram;i++){ fifo[i].page=-1; fifo[i].free=1; fifo[i].tag=0;}i=0;while(i<j){yn=0; for(z=0;z<ram;z++)if(fifo[z].page==page[i]){yn=1;for(z=0;z<ram;z++)if(fifo[z].free==0)fifo[z].tag+=1;}if(yn!=1){absent+=1; l=0;while((l<ram)&&(fifo[l].free==0))l++;if((l<ram)&&(fifo[l].free==1)){fifo[l].page=page[i];fifo[l].free=0;for(l=0;l<ram;l++)if(fifo[l].free==0)fifo[l].tag+=1;}else{t=0;for(l=0;l<ram;l++)if(fifo[l].tag<fifo[t].tag)t=l;fifo[t].page=page[i];fifo[t].free=0;fifo[t].tag=1;l=0;}}i++;}rate=(float)absent/j*100;return rate;}float LRU(int ram) /{int absent=0,yn,t,i,l,z,now=0;struct s2 P[250];for(i=0;i<j;i++)P[i].time=0;for(i=0;i<ram;i++){ lru[i].page=-1; lru[i].free=1;}i=0;while(i<j){for(l=0;z<ram;z++)yn=0;for(z=0;z<ram;z++){ if(lru[z].page==page[i]){ now+=1;P[lru[z].page].time=now;yn=1;}if(yn!=1){ absent+=1; now+=1; l=0;while((l<=ram)&&(lru[l].free==0)) l++;if((l<=ram)&&(lru[l].free==1)){lru[l].page=page[i];P[lru[l].page].time=now;lru[l].free=0;}else{t=0;for(l=0;l<ram;l++)if(P[lru[l].page].time<P[lru[t].page].time)t=1;lru[t].page=page[i];P[lru[t].page].time=now;}}}i++;}rate=(float)absent/j*100;return rate;}float OPT(int ram){int yn,t,absent=0,i,l1,k,l;for (i=0;i<ram;i++){opt[i].page=-1; opt[i].free=1; opt[i].tag=0;}i=0;while(i<j){yn=0;for (l1=0;l1<ram;l1++)if (page[i]==opt[l1].page){yn=1;for(k=0;k<ram;k++)opt[k].tag-=1;}if(yn!=1){ absent+=1; l=0;while((l<ram)&&(opt[l].free==0)) l++;if((l<=ram)&&(opt[l].free==1)){ opt[l].page=page[i]; opt[l].free=0; opt[l].tag=1;for(l=0;l<ram;l++){ opt[l].tag-=1;}}else{for(l=0;l<ram;l++){t=i;while(t<j&&opt[l].page!=page[t]){ t++;opt[l].tag+=1;}}t=0;for(l=0;l<ram;l++)if(opt[l].tag>opt[t].tag) t=l;opt[t].page=page[i];opt[t].tag=1;}}i++;}rate=(float)absent/j*100;return rate;}运行结果：。

操作系统页面置换算法_课程设计论文

操作系统页面置换算法_课程设计论文《操作系统》课程设计任务书题目:常用页面置换算法模拟实验学号: 学生姓名:班级:题目类型:软件工程，R，指导教师: 一、设计目的学生通过该题目的设计过程,掌握常用页面置换算法的原理、软件开发方法并提高解决实际问题的能力。

二、设计任务1、了解UNIX的命令及使用格式,熟悉UNIX/LINUX的常用基本命令,练习并掌握UNIX提供的vi编辑器来编译C程序,学会利用gcc、gdb编译、调试C程序。

2、设计一个虚拟存储区和内存工作区,并使用最佳淘汰算法，OPT，、先进先出算法，FIFO，、最近最久未使用算法，LRU，计算访问命中率。

，命中率,,,页面失效次数,页地址流长度，三、设计要求1、分析设计要求,给出解决方案，要说明设计实现所用的原理、采用的数据结构，。

2、设计合适的测试用例,对得到的运行结果要有分析。

3、设计中遇到的问题,设计的心得体会。

4、文档:课程设计打印文档每个学生一份,并装在统一的资料袋中。

5、光盘:每个学生的文档和程序资料建在一个以自己学号和姓名命名的文件夹下,刻录一张光盘,装入资料袋中。

四、提交的成果1. 设计说明书一份,内容包括:1) 中文摘要100字;关键词3-5个;2) 设计思想;3，各模块的伪码算法;4，函数的调用关系图;5，测试结果;6，源程序，带注释，;7，设计总结;8) 参考文献、致谢等。

2. 刻制光盘一张。

五、主要参考文献1. 汤子瀛,哲凤屏.《计算机操作系统》.西安电子科技大学学出版社.2. 王清,李光明.《计算机操作系统》.冶金工业出版社.3.,钟秀等. 操作系统教程. 高等教育出版社4.曾明. Linux操作系统应用教程. 陕西科学技术出版社.5. 张丽芬,刘利雄.《操作系统实验教程》. 清华大学出版社.6. 孙静, 操作系统教程,,原理和实例分析. 高等教育出版社7. 周长林,计算机操作系统教程. 高等教育出版社8. 张尧学,计算机操作系统教程,清华大学出版社9. 任满杰,操作系统原理实用教程,电子工业出版社10.张坤.操作系统实验教程,清华大学出版社六、各阶段时间安排，共2周，周次日期内容地点教师讲解设计要求教室星期一~二查找参考资料图书馆第1周星期三~五算法设计,编程实现教室星期一~三算法设计,编程实现教室第2周星期四~五检查程序,答辩教室2013年12月9日摘要操作系统是管理计算机系统的全部硬件资源包括软件资源及数据资源,控制程序运行改善人机界面,为其它应用软件提供支持等，使计算机系统所有资源最大限度地发挥作用，为用户提供方便的、有效的、友善的服务界面。

页面置换算法c语言

页面置换算法（Page Replacement Algorithm）是操作系统中用于管理计算机内存的一种算法。

当系统中的物理内存不足时，操作系统会选择内存中的一些页面，将它们从内存中移动到磁盘上，以便为新的页面提供空间。

以下是使用C语言实现FIFO（First-In, First-Out）页面置换算法的示例代码：c复制代码#include<stdio.h>#include<stdlib.h>#define MAX_FRAMES 100#define MAX_PAGES 1000int frames[MAX_FRAMES];int page_faults = 0;void insert(int page, int frames[], int* page_faults) {int i;for (i = 0; i < *page_faults; i++) {if (frames[i] == page) {// Page already exists in memoryreturn;}}for (i = *page_faults; i < MAX_FRAMES; i++) {if (frames[i] == -1) {// Frame is empty, insert page at the end of the arrayframes[i] = page;(*page_faults)++;return;}}// All frames are full, page must be replaced to make room for the new page frames[*page_faults] = page;(*page_faults)++;}int main() {int pages[MAX_PAGES];int num_pages, num_frames, i, j;int page_faults_array[MAX_PAGES];int page_faults = 0;int current_frames[MAX_FRAMES];for (i = 0; i < MAX_FRAMES; i++) {current_frames[i] = -1; // Initialize all frames as empty}printf("Enter the number of pages: ");scanf("%d", &num_pages);printf("Enter the number of frames: ");scanf("%d", &num_frames);for (i = 0; i < num_pages; i++) {printf("Enter page %d: ", i + 1);scanf("%d", &pages[i]);insert(pages[i], current_frames, &page_faults); // Insert page into memorypage_faults_array[i] = page_faults; // Store page fault count for each page in an array}printf("Page Faults: %d\n", page_faults); // Print total number of page faults for the entire sequence of pagesprintf("Page Faults for each page in the sequence:\n"); // Print page fault count for each page in the sequence of pagesfor (i = 0; i < num_pages; i++) {printf("Page %d: %d\n", pages[i], page_faults_array[i]); // Print the page fault count for each page in the array of page fault counts for each page in the sequence of pages (nested array) (Duh) (Sorry for the confusion) (It's actually not that confusing once you see it written out like this) (If you're still con。