课程设计课题

存储管理程序设计

摘 要

虚拟存储器作为现代操作系统中存储管理的一项重要技术,实现了内存扩充功能。而分页请求分页系统正好可以完美的支持虚拟存储器功能,它具有请求调页功能和页面置换功能。在进程运行过程中。若其所访问的页面不存在,而需把他们调入内存,但内存无空闲时间时,为了保证该程序能够正常运行,系统必须从内存中调出一页程序或数据送到磁盘的兑换区中,通常,把选择换出页面的算法称为页面置换算法。一个好的置换算法应该具有较低的页面更换频率,所以本次实验中用了FIFO,LRU,OPT三种重要的置换算法。

关键词:分页;虚拟存储;FIFO;LRU;OPT;

一、课程设计的目的和要求

1、目的:存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。本次设计的目的是通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式管理的页面置换算法。

2、要求:

(1).过随机数产生一个指令序列,共320条指令。其地址按下述原则生成:

①50%的指令是顺序执行的;

②25%的指令是均匀分布在前地址部分;

③25%的指令是均匀分布在后地址部分;

(2). 指令序列变换成页地址流

(3). 计算并输出下述各种算法在不同内存容量下的命中率。

二、系统需求分析与总体设计

存储管理程序是可以进行合理的分配空间,而请求页式管理是一种常用的虚拟存储管理技术,通过这种技术用三种不同的算法来分配地址空间,算出这三种算法的命中率。

1、定义页面的结构(既然用到了分页式管理就要先定义页面)

2、函数定义

3、写主函数用来调用三种算法

4、写好三种算法分别为:

(1)       FIFO(先进先出算法)这个算法的基本思想是:总是先淘汰一些驻留在内存时间最长的页面,即先进入内存的页面先被置换掉

(2)       LRU(最近最少使用算法)本算法的基本思想是:如果某一页被访问了,那么它很可能马上又被访问;反之,如果某一页很长时间没有被访问,那么最近也不太可能会被访问。

(3)       OPT(最优算法)这是最理想的页面置换算法:从内存中移出以后不再使用的页面;如无这样的页面,则选择以后最长时间内不需要访问的页面。

5、程序总体设计框图

Main( )

Initialize(pf)

框架初始化函数

FIFO

算法

LRU

算法

OPT

算法

三、详细设计

本实验中,命中率=1-页面失效次数/页地址流长度;在本实验中,页地址流长度为320,页面失效次数为每次访问相应指令时,该指令所对应的页不在内存的次数;随机数产生办法,由系统提供函数strand()和rand(),分别进行初始化和产生随机数。

1、定义页面的结构  

 

Typedef struct

{

Int pn,pfn,count,time;

}

pl_type;  其中pn为页号,pfn为面号,count为个周期内访问该页面次数time为访问时间。

2、函数定义

(1)void initialize():初始化函数,给每个相关的页面赋值。

(2)void FIFO():计算使用FIFO算法时的命中率。

(3)void LRU():计算使用LRU算法时的命中率。

(4)void OPT():计算使用OPT算法时的命中率。

3、主函数Main()

开始

(1).先找出是否有指令,产生指令队列(2).再按照要求的方法执行指令(3).将指定指令列转换成页地址流(题目中要求的是每页十个指令)(4).依次执行三种算法得出命中率

4、三种算法

(1)FIFO这个算法的基本思想是:总是

先淘汰一些驻留在内存时间最长的页面,

是否有指令

即先进入内存的页面先被置换掉。作业

只要把进入内存的各个页面按进入的时

计算出页号

间次序用链表链接起来,设定一个链表

首指针指向进入内存最早的一个页面,

新进入的页面放在链表的尾部,需要淘

汰某一个页面时,总是淘汰替换指针所

在实存队列查找该页号

指向的页面即可。先进先出算法在程序

按线性顺序访问逻辑地址空间时比较理

是否找到

想,否则效率不高。特别是在遇到循环

执行的程序段时,往往会把频繁访问的

页面,因其在内存驻留时间过长,                                                                                 yes

而周期性地淘汰掉。

no

新页号按序列加入实存序列

FIFO算法

计算出命中率

结束

开始

(2)LRU算法: 他的的基本思想是:如果某一页

被访问了,那么它很可能马上又被访问;反之,

如果某一页很长时间没有被访问,那么最近也不

是否有指令

太可能会被访问。这种算法考虑了程序设计的局

把新页放入队列,同时向下移动其余页号

部性原理。其实质是:当需要置换一页时,选择

最近一段时间内最久未使用的页面予以淘汰。

计算出页号

在实存队列中查找该页号

是否找到

新页进入队列,老页号移出

N

计算出命中率

结束

(3)OPT算法:这是最理想的页面置换算法:从内存中移出以后不再使用的页面;如无这样的页面,则选择以后最长时间内不需要访问的页面。本算法因为页面访问的顺序是很难预知的,所以不是一种实际的方法。

开始

是否有指令

计算出页号

Yes

在页面中查找是否存在

是否找到

将该页面导入空闲页面

no

是否有空闲页面

yes

no

计算出命中率

结束

按照指令队列查找以后指令找出每一页命中的距离,找出最大的或没命中的当前空闲页面

 

 

 

四、测试、调试过程

1、实验过程中遇到的问题:

起初开始接触题目的时候除了知道三种算法是怎么进行之外对于存储是一无所知,尤其是页式虚拟存储,后来经过网上查找资料才知道请求页式管理的调入方式是,当需要执行某指令二又发现它不在内存时或当执行某条指令需要访问其他数据或指令时,这些指令和数据不在内存中,从而发生缺页中断,系统将外出中相应的页面调入内存。

还有开始的时候需要生成随机数,后来进过查找才知道原来随机数还可以通过系统提供函数进行初始化和产生随机数

2、实验截图

 

五、结论与体会

通过切实的实验与分析,巩固了所学的有关页式存储管理的相关知识,更深层次地理解并掌握了LRU和随机淘汰算法的精髓。通过使用C语言模拟LRU和随机算法实现请求页式管理,进一步提高了我的编程能力,并且有助于将操作系统和C有机地结合起来,使我更加明白了学科之间是紧密联系的。此外,经过这次课程设计,我更加感悟到了,仅仅学习书本上的理论知识是不够的,要在平时多进行实际操作,这样才能融会贯通,更加牢固地掌握所学知识。在以后的学习过程中,我应该更加深入学习有关C的内容,提高自己的动手能力。我对于存储系统的了解大大的加深了,所有的东西都再是纸上谈兵,从基础的三种算法的实现:先进先出(FIFO)、最近最少使用(LRU)、最佳淘汰(OPT)、,可以清晰看出操作系统中一些原理性的东西,他的运行,他的工作方式,不只是靠自己对着课本的文字去想想了。

        而通过最优、最先、最差三种适应算法来对主存实现分配的过程中,更是深刻的体会到其中的微妙。分页管理中的运行结果出现之后一目了然,队列方式也是方便自如。是让书上不动的文字活了起来。

        整个实验下来,无论是翻课本查原理,还是上百度搜代码,都是促进我们学习实践的一大助力,让课堂上一些死板的知识流转在手指之间,跃现在荧屏上面。

 

 

 

六、参考文献

【1】 计算机操作系统  西安电子科技大学出版社。汤子瀛、哲凤屏、汤小丹编著

【2】VC++深入详解  电子工业出版社 。孙鑫 余安萍编著

【3】张尧学,史美林编著.计算机操作系统教程(第三版).清华大学出版社.2006

【4】http://www.baidu.com

。。。。。。

 

 

 

 

 

 

 

附录:源程序

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

#define TRUE 1

#define FALSE 0

#define INVALID -1

#define NULL 0

#define  zllc 320

#define  xy 32

#define  clear 100

/*以下统一解释  pn:page number,pfn:page frame number,pfc:page frame control*/

typedef struct /*页面结构*/

{

int pn; //页号

int pfn; //页面框架号

int count; //计数器

int time;  //时间

}

pc;

pc pl[xy]; /*页面线性结构---指令序列需要使用地址*/

typedef struct pfc_struct /*页面结构控制,调度算法的控制结构*/

{

int pn;

int pfn;

struct pfc_struct *next;

}

pfc_type;

pfc_type pfc[xy], *free_head, *busy_head, *busy_tail;

int zhihuan, a[zllc]; /* a[]为指令序列*/

int page[zllc], offset[zllc]; /*地址信息*/

int  initialize(int);

int  FIFO(int);

int  LRU(int);

int  OPT(int);

/*初始化pf*/

int initialize(int pf)

{

int i;

zhihuan=0;

for(i=0;i<xy;i++)

{

pl[i].pfn=INVALID; /*置页面控制结构中的页号,页面为空*/

pl[i].count=0; /*页面控制结构中的访问次数为0*/

pl[i].time=-1; /*访问的时间*/

}

for(i=0;i<pf-1;i++) /*建立pfc[i-1]和pfc[i]之间的链接*/

{

pfc[i].next=&pfc[i+1];

pfc[i].pfn=i;

}

pfc[pf-1].next=NULL;

pfc[pf-1].pfn=pf-1;

free_head=&pfc[0]; /*空页面队列的头指针为pfc[0]*/

return 0;

}

/*先进先出算法*/

int FIFO(int pf)

{

int i;

pfc_type *p; /*中间变量*/

initialize(pf); /*初始化相关页面控制用数据结构*/

busy_head=busy_tail=NULL; /*忙页面队列头,队列尾链接*/

for(i=0;i<zllc;i++)

{

if(pl[page[i]].pfn==INVALID) /*页面失效*/

{

zhihuan++; /*失效次数*/

if(free_head==NULL) /*无空闲页面*/

{

p=busy_head->next; //保存忙页面下一个页面

pl[busy_head->pn].pfn=INVALID; //把这个页面换出,更新它的数据成员

free_head=busy_head; /*释放忙页面队列的第一个页面*/

free_head->next=NULL; /*表明还是缺页*/

busy_head=p; //更新忙页面的队头指针

}

p=free_head->next;

free_head->pn=page[i];

pl[page[i]].pfn=free_head->pfn;

free_head->next=NULL;

/*使busy的尾为null*/

if(busy_tail==NULL)

{

busy_tail=busy_head=free_head;

}

else

{

//把刚刚换进来的接在busy_tail后面

busy_tail->next=free_head;

busy_tail=free_head;

}

free_head=p; //下一个空页面

}

}

printf("A.FIFO:%6.6f",1-(float)zhihuan/320);

return 0;

}

/*最近最久未使用算法least recently used*/

int LRU (int pf)

{

int min,minj,i,j,present_time; /*minj为最小值下标*/

initialize(pf);

present_time=0;

for(i=0;i<zllc;i++)

{

if(pl[page[i]].pfn==INVALID) /*页面失效*/

{

zhihuan++;

if(free_head==NULL) /*无空闲页面*/

{

min=32767; /*设置最大值*/

for(j=0;j<xy;j++) /*找出time的最小值*/

{

if(min>pl[j].time&&pl[j].pfn!=INVALID)

{

min=pl[j].time;

minj=j;

}

}

free_head=&pfc[pl[minj].pfn]; //腾出一个单元

pl[minj].pfn=INVALID;

pl[minj].time=0;

free_head->next=NULL;

}

pl[page[i]].pfn=free_head->pfn; //有空闲页面,改为有效

pl[page[i]].time=present_time;

free_head=free_head->next; //减少一个free 页面

}

else

{

pl[page[i]].time=present_time;//命中则增加该单元的访问次数

present_time++;

}

}

printf("B.LRU:%6.6f",1-(float)zhihuan/320);

return 0;

}

/*最佳置换算法*/

int OPT(int pf)

{

int i,j, max,maxpage,dist[xy];

initialize(pf);

for(i=0;i<zllc;i++)

{

if(pl[page[i]].pfn==INVALID) /*页面失效*/

{

zhihuan++;

if(free_head==NULL) /*无空闲页面*/

{

for(j=0;j<xy;j++)

{

if(pl[j].pfn!=INVALID) //在主存中的页面,即将找出一个被替换出去

dist[j]=32767;

else

dist[j]=0; //不在主存中的页面

}

for(j=0;j<xy;j++)

{

if((pl[j].pfn!=INVALID)&&(dist[j]==32767))

{

dist[j]=j;

}

}

max=0;

for(j=0;j<xy;j++) //找最远距离的,因为在主存中的最后一页即是在虚存中的最后一页

if(max<dist[j])

{

max=dist[j];

maxpage=j;

}

free_head=&pfc[pl[maxpage].pfn];

free_head->next=NULL;

pl[maxpage].pfn=INVALID;

}

pl[page[i]].pfn=free_head->pfn;

free_head=free_head->next;

}

}

printf("C.OPT:%6.6f\n",1-(float)zhihuan/320);

return 0;

}

int main()

{

int s,i;

srand((unsigned)time(NULL));

s=rand()%320;  /*找出指令*/

for(i=0;i<zllc;i+=4)  /*产生指令队列*/

{

if(s<0||s>319)

{

printf("When i==%d,Error,s==%d\n",i,s);

exit(0);

}

a[i]=s;  /*任选一指令访问点m*/

a[i+1]=a[i]+1;  /*顺序执行一指令*/

a[i+2]=rand()%(a[i+1]+1);

a[i+3]=a[i+2]+1;  /*顺序执行一指令*/

s=rand()%(319-a[i+3])+a[i+3]+1;

if((a[i+2]>318)||(s>319))

printf("a[%d+2],a number which is :%d and s==%d\n",i,a[i+2],s);

}

for(i=0;i<zllc;i++) /*将指令序列变换成页地址流*/

{

page[i]=a[i]/10;  /*题目中的要求每页大小10指令*/

offset[i]=a[i]%10;

}

for(i=4;i<=32;i++)  /*用户内存工作区从4个页面到32个页面*/

{

printf("%2d page frames:\n",i);

FIFO(i);

LRU(i);

OPT(i);

}

return 0;

}

OS存储管理——FIFO,LRU,OPT命中率的更多相关文章

  1. 操作系统的页面置换C++算法:OPT FIFO LRU CLOCK 计算缺页率

    暴力直接上代码,主要是用了vector来实现,有些方法比較费时,不太好,请各位大神斧正.这是个人的作业,  这是代码下载页http://download.csdn.net/detail/l631068 ...

  2. 缓存失效策略(FIFO,LRU,LFU)

    当缓存需要被清理时(比如空间占用已经接近临界值了),需要使用某种淘汰算法来决定清理掉哪些数据.常用的淘汰算法有下面几种: 1. FIFO:First In First Out,先进先出.判断被存储的时 ...

  3. python matplotlib 可视化操作实例

    具体代码: # encoding: utf-8 # coding = utf-8 import sys reload(sys) sys.setdefaultencoding('utf8') from ...

  4. 操作系统-存储管理(3)高速缓存Cache

    存储器的组织形式: 数据总是在相邻两层之间复制传送,最小传送单位是定长块,互为副本(不删除) ️指令和数据有时间局部性和空间局部性.   高速缓冲存储器Cache 介于CPU和主存储器间的高速小容量存 ...

  5. 精进之路之lru

    原理 LRU(Least recently used,最近最少使用)算法根据数据的历史访问记录来进行淘汰数据,其核心思想是“如果数据最近被访问过,那么将来被访问的几率也更高”. 实现1 最常见的实现是 ...

  6. 虚存管理页面置换算法 — FIFO和RUL算法模拟实现

    本篇博文为追忆以前写过的算法系列第一篇(20081021) 温故知新 目的: 为了解决内存容量有限与多作业执行的冲突.运用了虚拟存储技术.能从逻辑上对内存进行扩充,达到扩充内存的效果.分页存储管理是实 ...

  7. 缓存淘汰算法之FIFO

    前段时间去网易面试,被这个问题卡住,先做总结如下: 常用缓存淘汰算法 FIFO类:First In First Out,先进先出.判断被存储的时间,离目前最远的数据优先被淘汰. LRU类:Least ...

  8. [整理] LRU 算法的实现方式

    目录 概念 方法选择 实现方案(基于LinkedHashMap) 改进方案 1.LRU-K 2.Two queue 3.Multi Queue(MQ) LRU类算法对比 LRU 在 Redis 中的应 ...

  9. 【转】缓存淘汰算法系列之3——FIFO类

    原文地址:http://www.360doc.com/content/13/0805/16/13247663_304923435.shtml 1 FIFO 1.1. 原理 按照“先进先出(First ...

随机推荐

  1. java常用的设计模式

    设计模式:一个程序员对设计模式的理解:"不懂"为什么要把很简单的东西搞得那么复杂.后来随着软件开发经验的增加才开始明白我所看到的"复杂"恰恰就是设计模式的精髓所 ...

  2. CSS3 @keyframes 动画

    CSS3的@keyframes,它可以取代许多网页动画图像,Flash动画,和JAVAScripts. CSS3的动画属性 下面的表格列出了 @keyframes 规则和所有动画属性: 浏览器支持 表 ...

  3. XAMARIN.ANDROID SIGNALR 实时消息接收发送示例

    SignalR 是一个开发实时 Web 应用的 .NET 类库,使用 SignalR 可以很容易的构建基于 ASP.NET 的实时 Web 应用.SignalR 支持多种服务器和客户端,可以 Host ...

  4. django 学习第一天搭建环境

    目前django版本是1.10,我学习的基础教材是 Web Development with Django Cookbook, Second Edition 搭建好配置环境 ssh免认证登录 修改一下 ...

  5. 设计模式之工厂模式VS抽象工厂

    一.工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的. 工厂模式在<Java与模式>中分为三类:1)简单工厂模式(Simple Factor ...

  6. Oracle 列数据聚合方法汇总

    网上流传众多列数据聚合方法,现将各方法整理汇总,以做备忘. wm_concat 该方法来自wmsys下的wm_concat函数,属于Oracle内部函数,返回值类型varchar2,最大字符数4000 ...

  7. Mysql - 函数

    Mysql提供的函数是在是太多了, 很多我都见过, 别说用了. 园子里面, 有人弄了一个比较全的. MYSQL函数 我这里会将他写的完全拷贝下来, 中间会插入一些自己项目中使用过的心得 一.数学函数 ...

  8. kafka

    2016-11-13  20:48:43 简单说明什么是kafka? Apache kafka是消息中间件的一种,我发现很多人不知道消息中间件是什么,在开始学习之前,我这边就先简单的解释一下什么是消息 ...

  9. Linux+apache+mono+asp.net安装教程

    Linux+apache+mono+asp.net安装教程(CentOS上测试的) 一.准备工作: 1.安装linux系统(CentOS,这个就不多讲了) 2.下载所需软件 http-2.4.4.ta ...

  10. C#跨平台手机应用开发工具Xamarin尝试 与Eclipse简单对比

    Xamarin 支持使用C#开发基于Android.IOS.WindowsPhone应用开发,最大特点C#+跨平台,详细说明问度娘. 安装 研究 想体验研究的点击查看页面 Xamarin For Vi ...