存储管理程序的设计报告
仓库存储的管理制度（精选33篇）
仓库存储的管理制度（精选33篇）仓库存储的管理制度 管理制度的主要特征 1.权威性。
管理制度由具有权威的管理部门制定，在其适⽤范围内具有强制约束⼒，⼀旦形成，不得随意修改和违犯； 2.完整性。
⼀个组织的管理制度，必须包含所有执⾏事项，不能有所遗漏，如发现或新的执⾏事项产⽣，应相应的制定管理制度，确保所有事项“有法可依”； 3.排它性。
某种管理原则或管理⽅法⼀旦形成制度，与之相抵触的其他做法均不能实⾏；特定范围内的普遍适⽤性。
各种管理制度都有⾃⼰特定的适⽤范围，在这个范围内，所有同类事情，均需按此制度办理; 4.可执⾏性。
组织所设置的管理制度，必须是可执⾏的，不能偏离组织本⾝事务，成为⼀纸空⽂； 5.相对稳定性。
管理制度⼀旦制定，在⼀般时间内不能轻易变更，否则⽆法保证其权威性。
这种稳定性是相对的，当现⾏制度不符合变化了的实际情况时，⼜需要及时修订； 6.社会属性。
因⽽，社会主义的管理制度总是为维护全体劳动者的利益⽽制定的； 7.公平公正性。
管理制度在组织⼒对每⼀个⾓⾊都是平等的，任何⼈不得在管理制度之外。
仓库存储的管理制度 在充满活⼒，⽇益开放的今天，需要使⽤制度的场合越来越多，制度是⼀种要求⼤家共同遵守的规章或准则。
那么你真正懂得怎么制定制度吗？以下是⼩编整理的仓库存储的管理制度（精选33篇），希望能够帮助到⼤家。
仓库存储的管理制度1 ⼀、仓库⽇常管理 1仓库管理员必须合理、有序、科学的设置各类原料及成品的摆放区域，保持仓库整洁卫⽣，对易燃、易爆、易受潮的物资采取相应的安全防预措施； 2仓库管理员必须设置各类原料和成品进出的明细账簿和台帐，对当天发⽣的业务逐⼀记录，做到⽇清⽇结，确保物料进出与结存数据的准确⽆误。
3仓库管理员必须每天把所发⽣的原料和成品数据输⼊电脑，以便统计与查询。
4仓库管理员必须根据⽣产需要及原料库存情况合理安排采购计划，并严格控制各类物资的库存量。
5仓库管理员必须定期进⾏各类物品的分类整理，对存放期限较长，逾期失效等不良存货，按⽉编制报表送⼚部管理中⼼，并提出处理意见，责成财务及相关部门及时加以处理。
存储管理实验报告
int m=0;//已分配作业数
int flag;//分配成功标志
int isup,isdow n; //回收区域存在上邻和下邻的标志
int is=0;
struct jcb {
char n ame[10];
char state;
int ntime; //所需时间
给作业占用；另一部分又成为一个较小的空闲区，留在空闲区表中。 为了尽量减少由于
分割造成的空闲区，尽可能分配低地址部分的空闲区，而尽量保存高地址部分有较大的
连续空闲区域，以利于大型作业的装入。 为此，在空闲区说明表中，把每个空闲区按其 地址顺序从低到高登记， 即每个后继的空闲区其起始地址总是比前者大。为了方便查找
为了说明那些分区是空闲的，可以用来装入新作业，必须有一张空闲说明表
长度——指出从起始地址开始的一个连续空闲的长度。
状态一一有两种状态，一种是 “未分配”状态，指出对应的由起址指出的某个长度的 区域是空闲区；另一种是 “空表目”状态， 表示表中对应的登记项目是空白（无效） 可用来登记新的空闲区（例如，作业完成后，它所占的区域就成了空闲区，应找一个
{
JCB *first;
if(ready==NULL) ready=p;
else{
first=ready;
while(first->li nk!=NULL)
first=first->li nk;
first->li nk=p;
p->li nk=NULL;
}
}
void sort3()/*建立对已分配作业队列的排列函数，直接插在队列之尾*/
实验三、存储管理
操作系统存储管理实验报告
操作系统实验·报告
typedef struct pfc_struct pfc_type; (2)模块结构 (伙伴系统) # define Inital 1024 //初始时的总内存
NODE root=(memory_node *)malloc(1*sizeof(memory_node));//根节点 int chip=0; // 记录总的碎片大小
total = 256 use =127 remain_max = 0 flag = 0 pid =0
total = 256 use = 0 remain_max = 256 flag = 0 pid =-1
total = 1024 use = 0 remain_max = 512 flag = 1 pid =-1
total = 512 use = 0 remain_max = 512 flag = 0 pid =-1
total = 512 use = 267 remain_max = 0 flag = 0 pid = -1
6 / 37
操作系统实验·报告
三、实验理论分析
7 / 37
操作系统实验·报告
(伙伴算法) Buddy System 是一种经典的内存管理算法。在 Unix 和 Linux 操作系统中都有用到。其 作用是减少存储空间中的空洞、减少碎片、增加利用率。避免外碎片的方法有两种： a.利用分页单元把一组非连续的空闲页框映射到非连续的线性地址区间。 b.开发适当的技术来记录现存的空闲连续页框块的情况，以尽量避免为满足对小块的 请 求而把大块的空闲块进行分割。 基于下面三种原因，内核选择第二种避免方法： a.在某些情况下，连续的页框确实必要。 b.即使连续页框的分配不是很必要，它在保持内核页表不变方面所起的作用也是不容 忽视的。假如修改页表，则导致平均访存次数增加，从而频繁刷新 TLB。 c.通过 4M 的页可以访问大块连续的物理内存，相对于 4K 页的使用，TLB 未命中率降 低，加快平均访存速度。 Buddy 算法将所有空闲页框分组为 10 个块链表，每个块链表分别包含 1,2,4,8,16,32,64,128,256,512 个连续的页框，每个块的第一个页框的物理地址是该块 大小的整数倍。如，大小为 16 个页框的块，其起始地址是 16*2^12 的倍数。 例，假设要请求一个 128 个页框的块，算法先检查 128 个页框的链表是否有空闲块， 如果没有则查 256 个页框的链表，有则将 256 个页框的块分裂两份，一 份使用，一份 插入 128 个页框的链表。如果还没有，就查 512 个页框的链表，有的话就分裂为 128， 128，256，一个 128 使用，剩余两个插入对应链 表。如果在 512 还没查到，则返回 出错信号。 回收过程相反，内核试图把大小为 b 的空闲伙伴合并为一个大小为 2b 的单独块，满足 以下条件的两个块称为伙伴： a.两个块具有相同的大小，记做 b。 b.它们的物理地址是连续的。 c.第一个块的第一个页框的物理地址是 2*b*2^12 的倍数。 该算法迭代，如果成功合并所释放的块，会试图合并 2b 的块来形成更大的块。 为了模拟 Buddy System 算法，我采用了数的数据结构，并使用了结构体，来记录各项 数据与标记，虽然不是真正的操作系统使用的方法，但成功模拟了插入和回收的过程。 在回收时我采用物理上的合并——即删除实际的物理节点，释放空间。然而实际中可 能根据需要仅仅是删除了标记项，使之标记成没用过的，从而避免了合并，会提高下 一次的插入操作。 碎片百分比 = 碎片总大小/总内存大小 (置换算法)
操作系统存储管理实验报告
操作系统存储管理实验报告一、实验目的操作系统的存储管理是计算机系统中非常重要的组成部分，它直接影响着系统的性能和资源利用率。
本次实验的目的在于深入理解操作系统中存储管理的基本原理和方法，通过实际操作和观察，掌握存储分配、回收、地址转换等关键技术，并对不同存储管理策略的性能进行分析和比较。
二、实验环境本次实验在 Windows 10 操作系统下进行，使用 Visual Studio 2019 作为编程环境，编程语言为 C+＋。
三、实验内容（一）固定分区存储管理1、原理固定分区存储管理将内存空间划分为若干个固定大小的分区，每个分区只能装入一道作业。
分区的大小可以相等，也可以不等。
2、实现创建一个固定大小的内存空间数组，模拟内存分区。
为每个分区设置状态标志（已分配或空闲），并实现作业的分配和回收算法。
3、实验结果与分析通过输入不同大小的作业请求，观察内存的分配和回收情况。
分析固定分区存储管理的优缺点，如内存利用率低、存在内部碎片等。
（二）可变分区存储管理1、原理可变分区存储管理根据作业的实际需求动态地划分内存空间，分区的大小和数量是可变的。
2、实现使用链表或数组来管理内存空间，记录每个分区的起始地址、大小和状态。
实现首次适应、最佳适应和最坏适应等分配算法，以及分区的合并和回收算法。
3、实验结果与分析比较不同分配算法的性能，如分配时间、内存利用率等。
观察内存碎片的产生和处理情况，分析可变分区存储管理的优缺点。
（三）页式存储管理1、原理页式存储管理将内存空间和作业都划分为固定大小的页，通过页表将逻辑地址转换为物理地址。
2、实现设计页表结构，实现逻辑地址到物理地址的转换算法。
模拟页面的调入和调出过程，处理缺页中断。
3、实验结果与分析测量页式存储管理的页面置换算法（如先进先出、最近最少使用等）的命中率，分析其对系统性能的影响。
探讨页大小的选择对存储管理的影响。
（四）段式存储管理1、原理段式存储管理将作业按照逻辑结构划分为若干个段，每个段有自己的名字和长度。
存储管理实验报告_6
昆明理工大学信息工程与自动化学院学生实验报告（2012 —2013 学年第二学期）一、实验目的存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
通过本次实验, 要求学生通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解, 通过请求页式存储管理中页面置换算法模拟设计, 了解虚拟存储技术的特点, 掌握请求页式存储管理的页面置换算法。
二、实验原理及基本技术路线图（方框原理图）用C或C++语言模拟实现请求式分页管理。
要求实现: 页表的数据结构、分页式内存空间的分配及回收（建议采用位图法）、地址重定位、页面置换算法（从FIFO,LRU,NRU中任选一种）。
int subareaSize[num]={8,12,16,32,24,16,64,128,40,64};//分区大小Process *pro=NULL;//保持进程信息int ProcessNum=0;//进程数目int applyProcessNum=0;//每次申请进程数目int maxApplyNum=0;//最大可申请数目int *applyIndex=NULL;//申请进程队列int totalApplyNum=0;//申请总数int *assignPointer=NULL;//已分配内存的进程队列int assignFlag=0;//分配索引, 表示已申请队列已分配的进程数int exeIndex;//执行的进程号Node *subareaNode=new Node[3];//分区回收时, 进程所在分区及其前, 后分区信息LinkList createLinkList(int n );//建立空闲分区链Node firstFit(LinkList &head,Process pro);//首次适应算法Node nestFit(LinkList &head,Process pro,Node flag);//循环适应算法Node bestFit(LinkList &head,Process pro);//最佳适应算法Node worstFit(LinkList &head,Process pro);//最坏适应算法Node assign(LinkList &head,int orderIndex,int index,Node flagNode);//一次分区分配int assignMemory(LinkList &head);//内存分配void insertNode(LinkList &head,Node q,int index);//插入节点Node deleteNode(LinkList &head,int index);//删除节点int display(LinkList &head);//打印分区分配情况int lowAttemper(int *excursionPointer);//低级调度int findSubarea(LinkList &head,int index);//回收内存int creatProcess();//创建进程Process* randomCreatPro(int n);//随机产生进程下面是各种方法简述:(1) 最优替换算法, 即OPT算法。
操作系统课程设计报告
实践课设计报告课程名称操作系统课程设计模拟设计内存管理中的地址题目转换（动态分区、页式十进制）学院班级学号姓名指导教师年月日课程设计任务书学生姓名：专业班级：指导教师：工作单位：题目: 模拟设计内存管理中的地址转换（动态分区、页式十进制）初始条件：1．预备内容：阅读操作系统的内存管理章节内容，理解动态分区、页式、段式和段页式存储管理的思想及相应的分配主存的过程。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．下列内部存储器管理中地址转换，在完成指定存储管理技术中的地址转换基础上还可以选择其它内部存储器管理中的地址转换进行模拟设计并实现：⑴动态分区方案，用最先适用算法对作业实施内存分配，然后把作业地址空间的某一逻辑地址转换成相应的物理地址。
能够处理以下的情形：输入某一逻辑地址，程序能判断地址的合法性，如果合法，计算并输出相应的物理地址。
如果不能计算出相应的物理地址，说明原因。
⑵页式存储管理中逻辑地址到物理地址的转换（十进制）。
能够处理以下的情形：输入某一十进制逻辑地址，能检查地址的合法性，如果合法进行转换，否则显示“地址非法”；物理地址用十进制表示。
⑶页式存储管理中逻辑地址到物理地址的转换（八进制）。
能够处理以下的情形：输入某一八进制逻辑地址，能检查地址的合法性，如果合法进行转换，否则显示“地址非法”；物理地址用八进制表示。
⑷页式存储管理中逻辑地址到物理地址的转换（十六进制）。
能够处理以下的情形：输入某一十六进制逻辑地址，能检查地址的合法性，如果合法进行转换，否则显示“地址非法”；物理地址用十六进制表示。
⑸段式存储管理中逻辑地址到物理地址的转换。
能够处理以下的情形：指定内存的大小，进程的个数，每个进程的段数及段大小；能检查地址的合法性，如果合法进行转换，否则显示地址非法的原因。
⑹段页式存储管理中逻辑地址到物理地址的转换。
存储器读写和总线控制实验报告
存储器读写和总线控制实验报告目录一、实验目的 (2)1.1 熟悉存储器的基本概念和工作原理 (2)1.2 掌握存储器的基本读写操作 (4)1.3 理解总线控制系统的作用和原理 (5)二、实验设备 (6)2.1 存储器模块 (7)2.2 总线控制单元 (8)2.3 示波器 (10)2.4 逻辑分析仪 (11)2.5 计算机调试软件 (12)三、实验原理 (13)3.1 存储器的结构及读写机制 (14)3.2 总线控制的基本概念及组成 (15)3.3 实验中的关键信号和时序 (16)四、实验步骤 (18)4.1 连接实验设备 (19)4.2 加载存储器读操作程序 (21)4.3 观察并记录存储器读操作的时序和信号波形 (22)4.4 加载存储器写操作程序 (23)4.5 观察并记录存储器写操作的时序和信号波形 (24)4.6 调试和优化总线控制单元 (26)4.7 执行完整流程并检查读写数据的一致性 (27)五、实验结果与分析 (27)5.1 存储器读操作的实验结果及数据分析 (29)5.2 存储器写操作的实验结果及数据分析 (30)5.3 总线控制单元的调试效果及实验结果 (31)5.4 实验中遇到的问题与解决方案 (32)六、实验结论与建议 (34)6.1 实验总结 (35)6.2 改进建议 (36)6.3 未来研究 (37)一、实验目的本次实验的主要目的是通过实践操作，深入理解和掌握存储器的基本工作原理、读写操作以及总线控制的基本概念和实现方法。
本实验旨在：理解存储器的分类及其特点，包括只读存储器（ROM）、随机存取存储器（RAM）等。
掌握存储器的寻址方式、存储单元的访问规则以及数据读取写入的基本流程。
学习并实践总线的通信协议，包括信号线的分组、时序控制以及冲突检测与解决。
通过实际操作，培养动手能力和解决问题的能力，加深对计算机系统底层工作的认识。
1.1 熟悉存储器的基本概念和工作原理在实施存储器读写和总线控制实验之前，首先需要对存储器的基本概念和工作原理有一个清晰的认识。
页式存储管理实验报告
页式存储管理一、实验目的：掌握分页式存储管理的基本概念和实现方法。
要求编写一个模拟的分页式管理程序，并能对分页式存储的页面置换算法进行编写和计算各个算法的缺页率。
二、程序设计：首先创建页面链指针数据结构，并设计页面映像表，采用数组的方法给定页面映像。
申请缓冲区，将一个进程的逻辑地址空间划分成若干个大小相等的部分，每一部分称做页面或页。
每页都有一个编号，叫做页号，页号从0开始依次编排，如0，1，2……。
设置等大小的内存块。
初始状态：将数据文件的第一个页面装入到该缓冲区的第0块。
设计页面置换算法，这里分别采用最佳页面置换算法OPT和最近最久未使用置换算法LRU,并分别计算它们的缺页率，以比较它们的优劣。
三、算法说明：执行程序时，当主存没有可用页面时，为了选择淘汰主存中的哪一页面，腾出1个空闲块以便存放新调入的页面。
淘汰哪个页面的首要问题是选择何种置换算法。
该程序采用人工的方法选择，依置换策略选择一个可置换的页，并计算它们的缺页率以便比较。
/*分页式管理实验-源程序*/#include"stdio.h"#define N 16#define num 5 /*进程分配物理块数目*/int A[N]={1,2,3,4,5,6,7,8,5,2,3,2,7,8,1,4}; /*页表映像*/typedef struct page{ int address; /*页面地址*/struct page *next;}page;struct page *head,*run,*rear;void jccreat() /*进程分配物理块*/{ int i=1;page *p,*q;head=(page *)malloc(sizeof(page)); p=head;for(i=1;i<=num;i++) { q=(page *)malloc(sizeof(page));p->next=q; q->address=0; q->next=NULL; p=q; }rear=p;}int search(int n){page *p;int i=0;p=head;while(p->next){if(p->next->address==n){printf("Get it at the page %d\n",i+1);run=p;return 1;}p=p->next;i++;}return 0;}void changeOPT(int n,int position){int i;int total=0;int flag=1;int distance[num];int MAX;int order=0;page *p,*q;p=head->next;q=head->next;for(i=0;i<num;i++)distance[i]=100;i=0;while(p){if(p->address==0){flag=0;break;}p=p->next;i++;}if(!flag){p->address=n;printf("Change the page %d\n",i+1);}else{while(q){for(i=position;i<N;i++){if(q->address==A[i])distance[total]=i-position;}total++;q=q->next;}MAX=distance[0];for(i=0;i<num;i++){if(distance[i]>MAX){MAX=distance[i];order=i;}}printf("Change the page %d\n",order+1);i=0;while(p){if(i==order)p->address=n;i++;p=p->next;}}}void changeLRU(int n){int i=0;int flag=1;page *p,*delect;p=head->next;while(p){if(p->address==0){flag=0;p->address=n;printf("Change the page %d\n",i+1);break;}p=p->next;i++;}if(flag){delect=head->next;head->next=delect->next;printf("Delect from the head, and add new to the end.\n");delect->address=n;rear->next=delect;rear=delect;rear->next=NULL;}}float OPT(){int i;int lose=0;float losef;float percent;for(i=0;i<N;i++){if(search(A[i])==0){lose++;changeOPT(A[i],i);}}losef=lose;percent=1-(losef/N);return percent;}float LRU(){int i;int lose=0;float losef;float percent;page *p;for(i=0;i<N;i++){if(search(A[i])==0){lose++;changeLRU(A[i]);}else{p=run->next;run->next=p->next;rear->next=p;rear=p;rear->next=NULL;printf("Move it to end of queue.\n");}}losef=lose;percent=1-(losef/N);return percent;}main() /*主函数部分*/{float percent;int choice;printf("Select the arithmetic:\n(1)OPT\n(2)LRU\nyour choice is:"); scanf("%d",&choice);/*选择页面置换算法*/jccreat(); /*创建进程*/if(choice==1) /*采用OPT算法置换*/{percent=OPT(); /*计算OPT时的缺页率*/ printf("The percent of OPT is %f",percent);}else if(choice==2) /*采用LRU算法置换*/ {percent=LRU(); /*计算LRU时的缺页率*/ printf("The percent of OPT is %f",percent);}else printf("Your choice is invalid.");getch();}四．运行结果:最佳（Optimal）置换算法：最近最久未使用(LRU)置换算法：五、心得体会掌握分页式存储管理的基本概念和实现方法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
本课程设计的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式管理的页面置换算法。
1．过随机数产生一个指令序列，共320条指令。
其地址按下述原则生成：①50％的指令是顺序执行的；②25％的指令是均匀分布在前地址部分；③25％的指令是均匀分布在后地址部分；#具体的实施方法是：A. 在[0，B. 319]的指C. 令地址之间随机选区一起点M;B. 顺序执行一条指E. 令，F. 即执行地址为M+1的指G. 令；C. 在前地址[0，I. M+1]中随机选取一条指J. 令并执行，K. 该指L. 令的地址为M’;D. 顺序执行一条指N. 令，O. 其地址为M’+1；E. 在后地址[M’+2，Q. 319]中随机选取一条指R. 令并执行；F. 重复T. A—E，U. 直到执行320次指V. 令。
2．指令序列变换成页地址流设：（1）页面大小为1K；（2）用户存容量为4页到32页；（3）用户虚存容量为32K。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条—第9条指令为第0页（对应虚存地址为[0，9]）；第10条—第19条指令为第1页（对应虚存地址为[10，19]）；。
第310条—第319条指令为第31页（对应虚存地址为[310，319]）；按以上方式，用户指令可组成32页。
3. 计算并输出下述各种算法在不同存容量下的命中率。
A. FIFO先进先出的算法B. LRR最近最少使用算法C. OPT最佳淘汰算法（先淘汰最不常用的页地址）D. LFR最少访问页面算法E. NUR最近最不经常使用算法二、课程设计环境要求1、硬件环境PC机一台，0.99G存，2.00GHZ 主频2、软件环境Windows XP/2000系统，编程软件VC++。
三、设计任务介绍及系统需求分析本课程设计主要的目的是编制页面置换算法FIFO、LRU、LFU、NUR和OPT的模拟程序,并模拟其在存的分配过程。
同时根据页面走向，分别采用FIFO、LRU、LFU、NUR和OPT算法进行页面置换，统计命中率；为简化操作，在淘汰一页时，只将该页在页表中抹去,而不再判断它是否被改写过，也不将它写回到辅存。
本程序实现了操作系统中页式虚拟存储管理中缺页中断理想型淘汰算法，该算法在访问串中将来再也不出现的或是在离当前最远的位置上出现的页淘汰掉。
这样，淘汰掉该页将不会造成因需要访问该页又立即把它调入的现象。
该程序能按要求随机确定存大小，随机产生页面数，进程数，每个进程的页数，给进程分配的页数等，然后运用理想型淘汰算法对每个进程进行计算缺页数，缺页率，被淘汰的序列等功能。
四、概要设计系统分为4个子模块：初始化模块，FIFO、LRU、LFU、NUR和OPT的五个算法模块。
初始化模块：initialize( )初始化函数，给每个相关的页面赋值。
FIFO算法模块：计算使用FIFO算法时的命中率。
LRU算法模块：计算使用LRU算法时的命中率。
LFU算法模块：计算使用OPT算法时的命中率。
NUR算法模块：计算使用LFU算法时的命中率。
OPT算法模块：计算使用NUR算法时的命中率。
五、详细设计本实验的程序设计基本上按照实验容进行。
即首先用srand()和rand()函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。
相关定义如下：1 数据结构(1)页面类型typedef struct{int pn,pfn,count,time;}pl-type;其中pn 为页号,pfn为面号, count为一个周期访问该页面的次数, time为访问时间.(2) 页面控制结构pfc-struct{int pn,pfn;struct pfc_struct *next;}typedef struct pfc_struct pfc_type;pfc_type pfc_struct[xy],*free_head,*busy_head;pfc_type *busy_tail;其中pfc[xy]定义用户进程虚页控制结构,*free_head为空页面头的指针,*busy_head为忙页面头的指针,*busy_tail为忙页面尾的指针.2．函数定义（1）Void initialize( ):初始化函数,给每个相关的页面赋值.（2）Void FIFO( ):计算使用FIFO算法时的命中率.（3）Void LRU( ):计算使用LRU算法时的命中率.（4）Void OPT( ):计算使用OPT算法时的命中率.（5）Void LFU( ):计算使用LFU算法时的命中率.（6）Void NUR( ):计算使用NUR算法时的命中率.3.变量定义(1)int a[zl]: 指令流数据组.(2)int page[zllc]: 每条指令所属的页号.(3)int offset[zllc]: 每页装入10条指令后取模运算页号偏移值.(4)int pf: 用户进程的存页面数.(5)int disaffect: 页面失效次数.先进先出算法，即FIFO算法（First-InFirst-Outalgorithm）。
这种算法选择最先调入主存储器的页面作为被替换的页面。
它的优点是比较容易实现，能够利用主存储器中页面调度情况的历史信息，但是，没有反映程序的局部性。
因为最先调入主存的页面，很可能也是经常要使用的页面。
近期最少使用算法，即LFU算法（LeastFrequentlyUsedalgorithm）。
这种算法选择近期最少访问的页面作为被替换的页面。
显然，这是一种非常合理的算法，因为到目前为止最少使用的页面，很可能也是将来最少访问的页面。
该算法既充分利用了主存中页面调度情况的历史信息，又正确反映了程序的局部性。
但是，这种算法实现起来非常困难，它要为每个页面设置一个很长的计数器，并且要选择一个固定的时钟为每个计数器定时计数。
在选择被替换页面时，要从所有计数器中找出一个计数值最大的计数器。
因此，通常采用如下一种相对比较简单的方法。
最久没有使用算法，即LRU算法（LeastRecentlyUsedalgorithm）。
这种算法把近期最久没有被访问过的页面作为被替换的页面。
它把LFU算法中要记录数量上的"多"与"少"简化成判断"有"与"无"，因此，实现起来比较容易。
NUR算法NUR在需要淘汰某一页时，从那些最近一个时期未被访问的页中任选一页淘汰。
只要在页表中增设一个访问位即可实现。
当某页被访问时，访问位置1。
否则，访问位置0。
系统周期性地对所有引用位清零。
当需淘汰一页时，从那些访问位为零的页中选一页进行淘汰。
如果引用位全0或全1，NRU算法退化为FIFO算法。
最优替换算法，即OPT算法（OPTimalreplacementalgorithm）。
上面介绍的几种页面替换算法主要是以主存储器中页面调度情况的历史信息为依据的，它假设将来主存储器中的页面调度情况与过去一段时间主存储器中的页面调度情况是相同的。
显然，这种假设不总是正确的。
最好的算法应该是选择将来最久不被访问的页面作为被替换的页面，这种替换算法的命中率一定是最高的，它就是最优替换算法。
要实现OPT算法，唯一的办法是让程序先执行一遍，记录下实际的页地址流情况。
根据这个页地址流才能找出当前要被替换的页面。
显然，这样做是不现实的。
因此，OPT算法只是一种理想化的算法，然而，它也是一种很有用的算法。
实际上，经常把这种算法用来作为评价其它页面替换算法好坏的标准。
在其它条件相同的情况下，哪一种页面替换算法的命中率与OPT算法最接近，那么，它就是一种比较好的页面替换算法。
1.页面调度模拟算法流程示例图2.页面调度模拟算法示例图六、调试过程程序结果：从上述结果可知，在存页面数较少（4~5页）时，五种算法的命中率差别不大，都是30%左右。
在存页面为7~18个页面之间时，5种算法的访命中率大致在35%~60%之间变化。
但是，FIFO算法与OPT算法之间的差别一般在6~10个百分点左右。
在存页面为25~32个页面时，由于用户进程的所有指令基本上都已装入存，使命中率增加，从而算法之间的差别不大。
比较上述5种算法，以OPT算法的命中率最高，NUR算法次之，再就是LFU 算法和LRU算法，其次是FIFO算法。
就本问题，在15页之前，FIFO的命中率比LRU的高。
七、结论与体会这个程序基本完成了存储管理程序设计的目的与要求。
不过其中也有一些不足之处，例如算法有点麻烦，有些句子不是很能理解。
但是我通过上网查找资料，去图书馆借阅相关书籍解决了这些不足之处。
本次课程设计主要可以分为两个阶段，在第一个阶段中，要了解五种算法的执行原理，存的分配策略，存调页策略；第二个阶段主要是编制程序和运行改善程序。
通过编写程序可以更深入的理解算法和算法的特点。
这次操作系统的课程设计，让我对实验原理有更深的理解，通过把该算法的容，算法的执行顺序在计算机上实现，知道和理解了该理论在计算机中是怎样执行的，对该理论在实践中的应用有深刻的理解。
并且这次课程设计把各个学科之间的知识融合起来，把各门课程的知识联系起来，对计算机整体的认识更加深刻。
八、参考文献1、《计算机操作系统》汤子赢等电子科技大学2、《操作系统教程题解与实验指导》孟静高等教育 2003年3、《C语言程序设计》田祥宏等电子科技大学4、《软件工程》燕慧等5、《数据结构教程》（第三版）谢希仁等电子工业附件：源程序清单#include<stdlib.h>#include<stdio.h>#include<time.h>#define TRUE 1#define FALSE 0#define INVALID -1#define NULL 0#define zllc 320 /*指令流长*/#define xy 32 /*虚页长*/#define clear 50 /*清0周期*/typedef struct /*页面结构*/{int pn; //页号 logic numberint pfn; //页面框架号 physical frame numberint 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 LFU(int);int NUR(int);int OPT(int);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;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;offset[i]=a[i]%10;}for(i=4;i<=32;i++) /*用户存工作区从4个页面到32个页面*/{printf("%2d page frames:\n",i);FIFO(i);LRU(i);LFU(i);NUR(i);OPT(i);}return 0;}/*初始化相关数据结构 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) /*先进先出算法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("FIFO:%6.4f ",1-(float)zhihuan/320);return 0;}int LRU (int pf) /*最近最久未使用算法least recently used*/{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("LRU:%6.4f ",1-(float)zhihuan/320);return 0;}int NUR(int pf ) /*最近未使用算法Not Used recently count 表示*/{int i,j,dp,cont_flag,old_dp; //这个算法中count用于访问位initialize(pf);dp=0;for(i=0;i<zllc;i++){if (pl[page[i]].pfn==INVALID) /*页面失效*/{zhihuan++;if(free_head==NULL) /*无空闲页面*/{cont_flag=TRUE;old_dp=dp;while(cont_flag) //用cont_flag找到一个访问位count为0的页面{if(pl[dp].count==0&&pl[dp].pfn!=INVALID)cont_flag=FALSE;else //下一个页面{dp++;if(dp==xy) //32个页面找完一遍重新开始一个循环dp=0;if(dp==old_dp) // dp累积上一次访问到的地方old_dp，然后访问位重新清零for(j=0;j<xy;j++)pl[j].count=0;}}free_head=&pfc[pl[dp].pfn];pl[dp].pfn=INVALID;free_head->next=NULL;}pl[page[i]].pfn=free_head->pfn;free_head->pn=page[i];free_head=free_head->next;}elsepl[page[i]].count=1;if(i%clear==0)for(j=0;j<xy;j++)pl[j].count=0;}printf("NUR:%6.4f ",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;elsedist[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("OPT:%6.4f \n",1-(float)zhihuan/320);return 0;}/*该算法时根据已知的预测未知的，least frequency Used是最不经常使用置换法*/int LFU(int pf) //这个算法中count用于计数{int i,j,min,minpage;initialize(pf);for(i=0;i<zllc;i++){if(pl[page[i]].pfn==INVALID) /*页面失效*/{zhihuan++;if(free_head==NULL) /*无空闲页面*/{min=32767;/*获取count的使用用频率最小的存*/for(j=0;j<xy;j++){if(min>pl[j].count&&pl[j].pfn!=INVALID){min=pl[j].count;minpage=j;}}free_head=&pfc[pl[minpage].pfn];pl[minpage].pfn=INVALID;pl[minpage].count=0;free_head->next=NULL;}pl[page[i]].pfn=free_head->pfn; //有空闲页面,改为有效pl[page[i]].count++;free_head=free_head->next; //减少一个free 页面}else{pl[page[i]].count;pl[page[i]].count=pl[page[i]].count+1;}}printf("LFU:%6.4f ",1-(float)zhihuan/320);return 0;}。