精华内容
下载资源
问答
  • lru页面置换算法
    2021-11-15 16:54:38

    写这个算法,就是一步一步调试出来的,花点功夫,其实原理比较简单,我使用的是链表。
    中间有一些循环控制变量和条件需要琢磨以下,其他还好。

    #define vpNum 10	//虚页块数
    #define rpNum 3		//实页块数
    ElemType arr[N] = { 7,0,1,2,0,3,4,2,3,0,3,2,1,2,0,1,7,0,1 };//页面引用串
    

    完成这个分了三种情况:

    第一种情况,虚页号和页面号引用串值相等且此时不在内存中
    第二种情况,如果实页满了,进行页面置换
    第三种情况,此时刻的页面号在内存中
    

    完整代码:

    #include <stdio.h>
    #include <stdlib.h>
    typedef int ElemType;
    #define vpNum 10	//虚页块数
    #define rpNum 3		//实页块数
    #define N 20		//页面引用串数目
    #define MAX 100		//用于找最小访问时间的对比量,初值设置大一点
    ElemType arr[N] = { 7,0,1,2,0,3,4,2,3,0,3,2,1,2,0,1,7,0,1 };//页面引用串
    int count = 0;		//记录一共多少次缺页
    int sum = 1;		//记录时刻
    // 虚页数据结构
    typedef struct VirtualPage {
    	ElemType virtualPage;	//虚页号
    	ElemType realPage;		//实页号
    	ElemType state;			//状态
    	ElemType enterTime;		//进入时间
    	ElemType accessTime;	//访问时间
    	struct VirtualPage* next;
    	int len;
    }VirtualPage, * VP;
    // 实页数据结构
    typedef struct RealPage {
    	ElemType realPage;		//实页号
    	ElemType virtualPage;	//虚页号
    	ElemType state;			//状态
    	struct RealPage* next;
    	int len;
    }RealPage, * RP;
    //初始化虚页数据结构,尾插法
    void init_VP(VP& vp) {
    	vp = (VP)malloc(sizeof(VirtualPage));
    	VP q, r = vp;
    	vp->len = vpNum;
    	for (int i = 0; i < vp->len; i++) {
    		q = (VP)malloc(sizeof(VirtualPage));
    		q->virtualPage = i;
    		q->realPage = -1;
    		q->state = 0;
    		q->enterTime = 0;
    		q->accessTime = 0;
    		r->next = q;
    		r = q;
    	}
    	r->next = NULL;
    }
    //初始化虚页数据结构,尾插法
    void init_RP(RP& rp) {
    	rp = (RP)malloc(sizeof(RealPage));
    	RP q, r = rp;
    	rp->len = rpNum;
    	for (int i = 0; i < rp->len; i++) {
    		q = (RP)malloc(sizeof(RealPage));
    		q->realPage = i;
    		q->virtualPage = -1;
    		q->state = 0;
    		r->next = q;
    		r = q;
    	}
    	r->next = NULL;
    }
    //记录每个时刻为哪个页面上内存
    void print(VP vp) {
    	printf("***************************************************\n");
    	printf("\n时刻%d:\n", sum++);
    	printf("页面%d装入内存\n", vp->virtualPage);
    	printf("%3d", vp->virtualPage);
    	printf("\t%3d", vp->realPage);
    	printf("\t%3d", vp->state);
    	printf("\t%3d", vp->enterTime);
    	printf("\t\t%3d\n", vp->accessTime);
    }
    //打印虚页 实页当前时刻状态
    void showAns(VP vp, RP rp) {
    	vp = vp->next;
    	rp = rp->next;
    	printf("\n虚页号\t实页号\t状态\t加入时间\t访问时间\n");
    	while (vp != NULL) {
    		printf("%3d", vp->virtualPage);
    		printf("\t%3d", vp->realPage);
    		printf("\t%3d", vp->state);
    		printf("\t%3d", vp->enterTime);
    		printf("\t\t%3d\n", vp->accessTime);
    		vp = vp->next;
    	}
    
    	printf("\n实页号\t虚页号\t状态\n");
    	while (rp != NULL) {
    		printf("%3d", rp->realPage);
    		printf("\t%3d", rp->virtualPage);
    		printf("\t%3d\n", rp->state);
    		rp = rp->next;
    	}
    	printf("\n");
    }
    //LRU页面置换算法
    void function(VP vp, RP rp, ElemType arr[]) {
    	//创建的是带头结点的链表,所以指向头结点的下一个节点为 0号 节点的值
    	VP v = vp->next;
    	RP r = rp->next;
    	bool flag = false;//控制缺页置换操作完成后 跳出循环
    	for (int i = 0; i < N; i++) {
    		while (v != NULL) {
    			flag = false;//每次循环都要重置flag
    			//第一种情况,虚页号和页面号引用串值相等且此时不在内存中
    			if (v->virtualPage == arr[i] && v->state == 0) {
    				//如果实页没满,直接装入内存
    				if (count < rpNum) {
    					v->state = 1;//状态置为1
    					while (r != NULL) {
    						if (r->state == 0) {//找一个实页中的空块
    							r->state = 1;	//状态置为1
    							//修改虚页,实页中相关属性,与之对应
    							r->virtualPage = v->virtualPage;
    							v->realPage = r->realPage;
    							v->enterTime = i + 1;
    							v->accessTime = i + 1;
    							flag = true;//标志找到一个空块
    							print(v);
    							showAns(vp, rp);
    							count++;	//缺页次数加一
    							break;
    						}
    						r = r->next;//没找到符合要求的节点,继续向下找
    					}
    				}
    				//第二种情况,如果实页满了,进行页面置换
    				else {
    					VP temp = vp->next;
    					VP t = (VP)malloc(sizeof(VirtualPage));//临时节点,用来找到访问时间最小的节点
    					t->accessTime = MAX;
    					while (temp != NULL) {
    						//比大小
    						if (temp->accessTime < t->accessTime && temp->state == 1) {
    							t = temp;
    						}
    						temp = temp->next;
    					}
    					v->state = 1;//置换的页面状态改为1
    					t->state = 0;//被置换的页面状态改回0
    					while (r != NULL) {
    						//通过虚页的实页号找到实页中对应的实页块,并修改对应参数
    						if (t->realPage == r->realPage && r->state == 1) {
    							v->realPage = t->realPage;
    							t->realPage = -2;//表示装入过内存
    							v->enterTime = i + 1;
    							v->accessTime = i + 1;
    							r->virtualPage = v->virtualPage;
    							flag = true;//标志替换成功
    							print(v);
    							showAns(vp, rp);
    							count++;
    							break;
    						}
    						r = r->next;
    					}
    				}
    			}
    			//第三种情况,此时刻的页面号在内存中
    			else if (v->virtualPage == arr[i] && v->state == 1) {
    				v->accessTime = i + 1;//修改访问时间
    				flag = true;//标志操作完成
    				print(v);
    				showAns(vp, rp);
    				break;
    			}
    			if (flag) break;//三种情况中,任一种成功就直接判断下一个页面号,不成功再判断下一个虚页块是否满足要求
    			v = v->next;
    		}
    		//用于回到链表头。进行重新比对
    		v = vp->next;
    		r = rp->next;
    	}
    }
    int main() {
    	VP vp;
    	init_VP(vp);
    	RP rp;
    	init_RP(rp);
    	function(vp, rp, arr);
    	showAns(vp, rp);
    	int s = count + 1;
    	printf("\n该访问序列的缺页率为:%.2f%c\n\n\n\n",(s*1.0/N)*100,'%');
    	return 0;
    }
    
    更多相关内容
  • 使用LRU算法实现页面置换算法LRU算法基于一种假设,长期不使用的数据,在未来的使用性也不大。因此,当数据占用内存达到一定的阙值时,我们要移除最近最少使用的数据。LRU算法中,使用了一种有趣的数据结构,叫做...
  • LRU页面置换算法模拟 - 最近最久未使用置换算法 - 课程设计 LRU 页面置换算法模拟 - 最近最久未使用置换算法 | 课程设计 | 计算机数据库课程设计 一设计目的 1用 C 语言实现最近最久未使用 LRU置换算法 2了解内存...
  • LRU页面置换算法,使用Java语言编写,使用策略模式,可以方便的换成其他页面置换算法!相当好!
  • LRU页面置换算法

    2014-04-15 11:59:33
    C语言实现的对操作系统中LRU页面置换算法的模拟,有dos输出界面,简单明了
  • 为简化嵌入式虚拟内存的实现,改善嵌入式虚拟内存的性能,在对常见页面置换算法进行对比分析的基础上,提出一种改进的最久未使用页面置换算法。该算法基于内存管理单元、跨页访问计数器、访问次序寄存器、溢出中断...
  • LRU页面置换算法模拟(最近最久未使用置换算法).doc
  • 页面置换算法LRU (1)建立相应的数据结构; (2)在屏幕上显示物理块的变化,可逐步展示或完整展示; (3)设计页面访问序列,可以展现你所设计的页面置换算法; (4)计算页面的缺页次数、缺页后的页面置换次数
  • LRU 页面置换算法

    万次阅读 2019-06-09 19:45:59
    LRU是Least Recently Used的缩写,即最近最少使用,常用于页面置换算法,是为虚拟页式存储管理服务的。 为了尽量减少与理想算法的差距,产生了各种精妙的算法,最少使用页面置换算法便是其中一个。LRU算法的提出,是...

    LRU的简单实现
    LRU是Least Recently Used的缩写,即最近最少使用,常用于页面置换算法,是为虚拟页式存储管理服务的。
    为了尽量减少与理想算法的差距,产生了各种精妙的算法,最少使用页面置换算法便是其中一个。LRU算法的提出,是基于这样一个事实:在前面几条指令中使用频繁的页面很可能在后面的几条指令中频繁使用。反过来说,已经很久没有使用的页面很可能在未来较长的一段时间内不会被用到。这个,就是著名的局部性原理–比内存速度还要快的cache,也是基于同样的原理运行的。因此,我们只需要在每次调换时,找到最近最久未使用的那个页面调出内存。这就是LRU算法的全部内容。
    在这里插入图片描述
    在这里插入图片描述

    #include<iostream>
    #define N 3
    using namespace std;
    int main()
    {
        int ym[]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};
        int lru[N]={1,0,7};
        int len[N]={0,0,0};
        int allchagetimes=0;
         for(int t=0;t<N;t++)
           {
               cout<<lru[t]<<"  ";
           }
           cout<<endl;
    
       for(int i=3;i<20;i++)
       {
           int flag=0;
           int j=0;
           int sum=0;
           for(;j<N;j++)
           {
               if(ym[i]==lru[j])
               {
                   flag=1;
                   break;
               }
               else if(ym[i]!=lru[j])
               {
                   sum++;
                   if(sum==3)
                   {
                       flag=0;
                       break;
                   }
               }
    
    
           }
    
           if(flag==1)
           {
               int temp=lru[0];
             if(j==0)
             {
    
             }
             else if(j==1)
             {
                lru[0]=lru[j];
    
                 lru[2]=lru[2];
                 lru[1]=temp;
             }
    
             else if(j==2)
             {
                 lru[0]=lru[j];
    
                 lru[2]=lru[1];
                 lru[1]=temp;
    
             }
    
           }
           else if(flag==0)
           {
               allchagetimes++;
               lru[2]=lru[1];
               lru[1]=lru[0];
               lru[0]=ym[i];
    
    
           }
    
           for(int t=0;t<N;t++)
           {
               cout<<lru[t]<<"  ";
           }
           cout<<endl;
       }
    
       cout<<"缺页"<<allchagetimes+3 <<"次,置换"<<allchagetimes<<"次"<<endl;
    
    }
    
    

    在这里插入图片描述

    展开全文
  • LRU页面置换算法的两种实现方式(栈和寄存器) 1、在使用栈作为模拟最近最久未使用算法的支持设备时,把栈底元素作为最近最久未使用页面的页面编号,并编写相应的函数实现其功能。 2、在使用寄存器作为模拟最近最久...

    栈实现

    1、各类数据结构

    const int  N = 100;
    int stack[N];
    int top;//栈顶指针
    int MAXSIZE;//栈的最大容量
    int num, num_z;//用于计算缺页率
    

    2、各类函数的实现

    int check_same(int id)//判断栈中是否有相同页面,若有返回此页面在战中的位置
    {
    	for (int i = 0; i < top; i++)
    	{
    		if (id == stack[i])
    		{
    			return i;
    		}
    	}
    	return -1;
    }
    
    void push(int id)//入栈操作
    {
    	if (check_same(id) == -1 && !full())//栈中没有此页面,且栈没有满
    	{
    		printf("发生中断,页面%d被调入\n", id);
    		stack[top++] = id;
    		num_z++;
    	}
    	else if (check_same(id) == -1 && full())//栈中没有此页面,且栈满,需要将最近最久未使用的元素即栈底元素调出
    	{
    		printf("发生中断,页面%d被页面%d替换\n", stack[0],id);
    		for (int i = 0; i < top; i++)
    		{
    			stack[i - 1] = stack[i];
    		}
    		stack[top - 1] = id;
    		num_z++;
    	}
    	else if (check_same(id) != -1)//栈中有此页面
    	{
    		printf("页面%d在内存中。不发生中断。刷新页面%d的驻留时间\n", id, id);
    		int pos = check_same(id);
    		for (int i = pos; i < top - 1; i++)
    		{
    			stack[i] = stack[i + 1];
    		}
    		stack[top - 1] = id;
    	}
    }
    
    
    void show_stack()//显示栈中页面及详细页面展示
    {
    	int cnt = 0;
    	printf("---------------------------------\n");
    	printf("页面号:    ");
    	for (int i = top - 1; i >= 0; i--)
    	{
    		printf("|%2d|", stack[i]);
    	}
    	printf("\n");
    	printf("驻留时间: ");
    	for (int i = top - 1; i >= 0; i--)
    	{
    		printf("|%2d|", cnt++);
    	}
    	printf("\n---------------------------------");
    	printf("\n\n");
    }
    
    
    void page_missing_rate()//计算缺页率
    {
    	float tmp = (num_z * 1.0 / num) * 100;
    	printf("缺页率为:%.2f%%\n\n", tmp);
    }
    

    3、主函数

    int main()
    {
    	int ne = -1;
    	printf("******LRU页面置换算法(栈实现)******\n\n\n");
    	printf("请输入存储区块数:");
    	scanf("%d", &MAXSIZE);
    	printf("请输入要调入的页面:");
    	while (ne != 0)
    	{
    		num++;
    		scanf("%d", &ne);
    		printf("\n");
    		push(ne);
    		show_stack();
    		page_missing_rate();
    		printf("请输入要调入的页面:");
    	}
    }
    

    4、栈实现方式完整代码

    #include<stdio.h>
    
    const int  N = 100;
    int stack[N];
    int top;//栈顶指针
    int MAXSIZE;//栈的最大容量
    int num, num_z;//用于计算缺页率
    
    bool full()//判断栈是否已满
    {
    	if (top == MAXSIZE)
    		return true;
    	return false;
    }
    
    int check_same(int id)//判断栈中是否有相同页面,若有返回此页面在战中的位置
    {
    	for (int i = 0; i < top; i++)
    	{
    		if (id == stack[i])
    		{
    			return i;
    		}
    	}
    	return -1;
    }
    
    void push(int id)//入栈操作
    {
    	if (check_same(id) == -1 && !full())//栈中没有此页面,且栈没有满
    	{
    		printf("发生中断,页面%d被调入\n", id);
    		stack[top++] = id;
    		num_z++;
    	}
    	else if (check_same(id) == -1 && full())//栈中没有此页面,且栈满,需要将最近最久未使用的元素即栈底元素调出
    	{
    		printf("发生中断,页面%d被页面%d替换\n", stack[0],id);
    		for (int i = 0; i < top; i++)
    		{
    			stack[i - 1] = stack[i];
    		}
    		stack[top - 1] = id;
    		num_z++;
    	}
    	else if (check_same(id) != -1)//栈中有此页面
    	{
    		printf("页面%d在内存中。不发生中断。刷新页面%d的驻留时间\n", id, id);
    		int pos = check_same(id);
    		for (int i = pos; i < top - 1; i++)
    		{
    			stack[i] = stack[i + 1];
    		}
    		stack[top - 1] = id;
    	}
    }
    
    
    void show_stack()//显示栈中页面及详细页面展示
    {
    	int cnt = 0;
    	printf("---------------------------------\n");
    	printf("页面号:    ");
    	for (int i = top - 1; i >= 0; i--)
    	{
    		printf("|%2d|", stack[i]);
    	}
    	printf("\n");
    	printf("驻留时间: ");
    	for (int i = top - 1; i >= 0; i--)
    	{
    		printf("|%2d|", cnt++);
    	}
    	printf("\n---------------------------------");
    	printf("\n\n");
    }
    
    
    void page_missing_rate()//计算缺页率
    {
    	float tmp = (num_z * 1.0 / num) * 100;
    	printf("缺页率为:%.2f%%\n\n", tmp);
    }
    
    
    int main()
    {
    	int ne = -1;
    	printf("******LRU页面置换算法(栈实现)******\n\n\n");
    	printf("请输入存储区块数:");
    	scanf("%d", &MAXSIZE);
    	printf("请输入要调入的页面:");
    	while (ne != 0)
    	{
    		num++;
    		scanf("%d", &ne);
    		printf("\n");
    		push(ne);
    		show_stack();
    		page_missing_rate();
    		printf("请输入要调入的页面:");
    	}
    }
    

    5、运行示例

    在这里插入图片描述

    寄存器实现

    1、各类数据结构

    const int N = 100;
    int MAXSIZE;
    int num, num_z;
    const int reg_size = 8; //寄存器总位数
    int reg[N];	//记录每个页面的移位寄存器代表的数值
    int store[N];
    int Sum;//记录已存入元素的个数
    

    2、各类函数实现

    void change_R()	//改变页面R值
    {
    	for (int i = 0; i < Sum; i++)
    	{
    			reg[i] >>= 1;
    	}
    }
    
    int check_same(int id)	//寻找是否有相同页面,并返回该页面下标
    {
    	for (int i = 0; i < Sum; i++)
    	{
    		if (id == store[i])
    			return i;
    	}
    	return -1;
    }
    
    bool full()	//判断内存区是否已经装满
    {
    	if (Sum == MAXSIZE)
    		return true;
    	else
    		return false;
    }
    
    int find()	//寻找淘汰页面
    {
    	int Min = INT_MAX;
    	int pos = -1;
    	int i;
    	for (i = 0; i < Sum; i++)
    	{
    		if (reg[i] < Min)
    		{
    			Min = reg[i];
    			pos = i;
    		}
    	}
    	return pos;
    }
    
    void page_input(int id)//装入页面
    {
    	if (check_same(id) == -1 && !full())	//物理块没有使用完,且内存中没有此页面
    	{
    		printf("发生中断,页面%d被调入\n", id);
    		reg[Sum] = 1 << reg_size - 1;
    		store[Sum++] = id;
    		num_z++;
    	}
    	else if (check_same(id) == -1 && full())	//物理块已满,且内存中没有此页面
    	{
    		int pos = find();
    		printf("发生中断,页面%d被页面%d替换\n", store[pos], id);
    		store[pos] = id;
    		reg[pos] = 1 << reg_size - 1;
    		num_z++;
    	}
    	else if (check_same(id) != -1)	//内存中有此页面
    	{
    		printf("页面%d在内存中,不发生中断,刷新页面%d的R值\n", id, id);
    		int pos = check_same(id);
    		reg[pos] = reg[pos] | 1 << reg_size - 1;
    
    	}
    }
    
    void show_store()	//显示内存中的页面及详细信息展示
    {
    	printf("---------------------------------\n");
    	printf("页面号:    ");
    	for (int i = 0; i < Sum; i++)
    	{
    		printf("|%2d|", store[i]);
    	}
    	printf("\n");
    	printf(" R 值 :    ");
    	for (int i = 0; i < Sum; i++)
    	{
    		printf("|%2d|", reg[i]);
    	}
    	printf("\n---------------------------------");
    	printf("\n\n");
    }
    
    void page_missing_rate()	//计算缺页率
    {
    	double tmp = num_z * 1.0 / num * 100;
    	printf("缺页率为:%.2f%%\n\n", tmp);
    }
    

    3、主函数

    int main()
    {
    	int ne_page = -1;
    	printf("******LRU页面置换算法(寄存器实现)******\n\n\n");
    	printf("请输入要分配的物理块数:");
    	scanf("%d", &MAXSIZE);
    	printf("请输入要调入的页面:");
    	while (ne_page != 0)
    	{
    		num++;
    		scanf("%d", &ne_page);
    		printf("\n");
    		page_input(ne_page);
    		show_store();
    		change_R();
    		page_missing_rate();
    		printf("请输入要调入的页面:");
    	}
    }
    
    

    4、寄存器实现方式完整代码

    #include<stdio.h>
    #include<limits.h>
    
    const int N = 100;
    int MAXSIZE;
    int num, num_z;
    const int reg_size = 8; //寄存器总位数
    int reg[N];	//记录每个页面的移位寄存器代表的数值
    int store[N];
    int Sum;//记录已存入元素的个数
    
    void change_R()	//改变页面R值
    {
    	for (int i = 0; i < Sum; i++)
    	{
    			reg[i] >>= 1;
    	}
    }
    
    int check_same(int id)	//寻找是否有相同页面,并返回该页面下标
    {
    	for (int i = 0; i < Sum; i++)
    	{
    		if (id == store[i])
    			return i;
    	}
    	return -1;
    }
    
    bool full()	//判断内存区是否已经装满
    {
    	if (Sum == MAXSIZE)
    		return true;
    	else
    		return false;
    }
    
    int find()	//寻找淘汰页面
    {
    	int Min = INT_MAX;
    	int pos = -1;
    	int i;
    	for (i = 0; i < Sum; i++)
    	{
    		if (reg[i] < Min)
    		{
    			Min = reg[i];
    			pos = i;
    		}
    	}
    	return pos;
    }
    
    void page_input(int id)//装入页面
    {
    	if (check_same(id) == -1 && !full())	//物理块没有使用完,且内存中没有此页面
    	{
    		printf("发生中断,页面%d被调入\n", id);
    		reg[Sum] = 1 << reg_size - 1;
    		store[Sum++] = id;
    		num_z++;
    	}
    	else if (check_same(id) == -1 && full())	//物理块已满,且内存中没有此页面
    	{
    		int pos = find();
    		printf("发生中断,页面%d被页面%d替换\n", store[pos], id);
    		store[pos] = id;
    		reg[pos] = 1 << reg_size - 1;
    		num_z++;
    	}
    	else if (check_same(id) != -1)	//内存中有此页面
    	{
    		printf("页面%d在内存中,不发生中断,刷新页面%d的R值\n", id, id);
    		int pos = check_same(id);
    		reg[pos] = reg[pos] | 1 << reg_size - 1;
    
    	}
    }
    
    void show_store()	//显示内存中的页面及详细信息展示
    {
    	printf("---------------------------------\n");
    	printf("页面号:    ");
    	for (int i = 0; i < Sum; i++)
    	{
    		printf("|%2d|", store[i]);
    	}
    	printf("\n");
    	printf(" R 值 :    ");
    	for (int i = 0; i < Sum; i++)
    	{
    		printf("|%2d|", reg[i]);
    	}
    	printf("\n---------------------------------");
    	printf("\n\n");
    }
    
    void page_missing_rate()	//计算缺页率
    {
    	double tmp = num_z * 1.0 / num * 100;
    	printf("缺页率为:%.2f%%\n\n", tmp);
    }
    
    int main()
    {
    	int ne_page = -1;
    	printf("******LRU页面置换算法(寄存器实现)******\n\n\n");
    	printf("请输入要分配的物理块数:");
    	scanf("%d", &MAXSIZE);
    	printf("请输入要调入的页面:");
    	while (ne_page != 0)
    	{
    		num++;
    		scanf("%d", &ne_page);
    		printf("\n");
    		page_input(ne_page);
    		show_store();
    		change_R();
    		page_missing_rate();
    		printf("请输入要调入的页面:");
    	}
    }
    
    
    

    5、运行示例

    在这里插入图片描述

    小结

    LRU页面置换算法是选择最近最久未使用的页面进行淘汰,需要有栈和寄存器两类硬件之一的支持。
    1、在使用栈作为模拟最近最久未使用算法的支持设备时,把栈底元素作为最近最久未使用页面的页面编号,并编写相应的函数实现其功能。
    2、在使用寄存器作为模拟最近最久未使用算法的支持设备时,R值最小的则是最近最久未使用页面的页面编号。可以利用位运算来模拟寄存器,从而实现这种算法。每当进程访问某物理块时,将该物理块所对应的数组中的数字的最高位置1,并且每隔一定的时间把所有数字右移一位。

    展开全文
  • lru页面置换算法模拟最近最久未使用置换算法课程设计.pdflru页面置换算法模拟最近最久未使用置换算法课程设计.pdflru页面置换算法模拟最近最久未使用置换算法课程设计.pdflru页面置换算法模拟最近最久未使用置换算法...
  • lru页面置换算法模拟最近最久未使用置换算法课程设计 (2).pdflru页面置换算法模拟最近最久未使用置换算法课程设计 (2).pdflru页面置换算法模拟最近最久未使用置换算法课程设计 (2).pdflru页面置换算法模拟最近最久未...
  • lru页面置换算法模拟最近最久未使用置换算法课程设计 (2).docxlru页面置换算法模拟最近最久未使用置换算法课程设计 (2).docxlru页面置换算法模拟最近最久未使用置换算法课程设计 (2).docxlru页面置换算法模拟最近最...
  • 大学课程操作系统会有很多实验,LRU页面置换也是其中的一部分,希望能够参考,此LRU内存最大块为五块,可以修改成最大块为输入限制。
  • LRU页面置换算法实现

    2014-05-09 18:34:35
    LRU页面置换算法实现 一请求分页存储系统,进程P共有5页,访问串为3,2,1,0,3,2,4,3,2,1,0,4,试采用LRU算法和LFU算法分析,当分配页面数为3时,发生的缺页中断次数
  • import java.util.LinkedList;import java.util.List...public class LRU {static int volum;// 栈的容量static Listlist=new LinkedList();//链表用来模拟栈存放页面static int[]visit;//要访问的页面数组static in...

    0_1291613353Qhy2.gifimport java.util.LinkedList;

    import java.util.List;

    import java.util.Scanner;

    public class LRU {

    static int volum;// 栈的容量

    static Listlist=new LinkedList();

    //链表用来模拟栈存放页面

    static int[]visit;//要访问的页面数组

    static int count=0;//记录缺页次数

    public static void main(String []args)

    {

    Scanner sc = new Scanner(System.in);

    System.out.print("请输入栈的容量:");

    volum=sc.nextInt();

    System.out.print("请输入总页面数目:");

    int n=sc.nextInt();

    visit=new int[n];

    System.out.println("请输入各个页的页面号码:");

    for(int i=0;i

    visit[i]=sc.nextInt();

    sLRU();//调用最近最久未使用

    System.out.println("置换页面的数目为:"+count);

    }

    public static void sLRU()

    {

    int index=0;

    while(index

    {

    boolean flag=false;

    if(list.size()<=volum)

    {

    for(int i=0;i

    {

    if((int)(list.get(i))==visit[index])

    {

    list.remove(i);//先删除

    list.add(visit[index]);//再添加到尾部

    flag=true;

    break;

    }

    }

    if(!flag)

    {

    if(list.size()

    {//如果栈未满,而且此页面没有在栈中,就将它入栈

    list.add(visit[index]);

    }

    else

    {//如果栈已经满了,且该页面号码没有在栈中,就把栈底元素删除,将新页插入

    int temp=list.get(0);

    list.remove(0);//最开始一个换出

    list.add(visit[index]);//加到末尾

    count++;

    System.out.println("开始换页了,将栈底的"+temp+"换出");

    System.out.println("这也是没有办法的事情,毕竟栈是有限的");

    }

    }

    System.out.print("经过第"+(index+1)+"个页面的栈内容为");

    for(int k=0;k

    System.out.print(list.get(k)+" ");

    System.out.println();

    index++;

    }

    }

    }

    }

    展开全文
  • ### 什么是LRU页面置换算法 LRU(Least Recently Used),是页面置换算法的一种,它的主要思想是当用于缓存页面的地址块已满时,选择最久未使用的页面删除,然后用将新请求的页面加入缓存。 例如:请求为 {1,2, 0, 3...
  • LRU页面置换算法C语言实现

    千次阅读 2021-05-10 11:00:08
    LRU 最近最少使用页面置换算法 思路: 代码: #include<stdio.h> #include<string.h> void Change(int P[],int x,int y){//将p数组中x位置的元素挪到y位置 //我们默认传参进来的 x大于 y 也...
  • 这是一个自己完成软件工程的操作系统课程课程设计题目:此程序用于模拟虚拟磁盘页面置换算法,实现了FIFO页面置换算法和LRU页面置换算法,获得课程设计优秀的好成绩
  • 操 作 系 统 实 验 报 告 页面置换算法模拟 OFTFIFO 和 LRU 算法 班级2013 级软件工程 1 班 学号X X X 姓名萧氏一郎 开始载入序列 开始 载入序列号从第 0 个得到页号 将页号放入物理地址中编号 s 根据选择的置换算法...
  • LRU的思想实现缺页中断以及页面置换。C语言实现,按照最近最久未被访问的思想去实现这个算法。输出每一次页面置换之后的过程以及最后的缺页中断次数与缺页中断率。
  • 操作系统-LRU页面置换算法模拟.doc
  • 操作系统——FIFO和LRU页面置换算法

    万次阅读 多人点赞 2018-06-16 19:45:16
    先进先出FIFO页面置换算法(来自百度百科-先进先出页面置换算法)简介:优先淘汰最早进入内存的页面,亦即在内存中驻留时间最久的页面。该算法实现简单,只需把调入内存的页面根据先后次序链接成队列,设置一个指针...
  • 内存FIFO、LRU页面置换算法的设计.doc
  • 页面置换算法(java)

    2021-02-26 14:18:35
    在一个请求分页系统中,分别采用最佳置换算法、先进先出置换算法、最近最久未使用置换算法(LRU)时,假如一个作业的页面走向为4、3、2、1、4、3、5、4、3、2、1、5,当分配给该作业的物理块数M分别为3和4时,试计算在...
  • LRU页面置换算法的改进与实现.pdf
  • lru页面置换算法

    2011-12-04 10:30:31
    操作系统的页面置换算法的详细代码,是dos系统下的模拟实验算法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,460
精华内容 4,184
关键字:

lru页面置换算法