南通大学计算机科学与技术学院
文案大全
操作系统课程设计报告
专业：
学生姓名： 学号： 时间：
实用文档
操作系统模拟算法课程设计报告
设计要求
将本学期三次的实验集成实现： A.处理机管理； B.存储器管理；
C.虚拟存储器的缺页调度。
设计流程图
主流程图
处理机管理 先 来 先 开始的图形界面 存储器管理 缺页调度 时间片轮转 首次适应法 最佳适应法 先进先出 LRU算法 服务 文案大全
实用文档
A.处理机调度
1)先来先服务FCFS
开始 初始化进程控制块，让进程控制块按进程到达先后顺序让进程排队 调度数组中首个进程，并让数组中的下一位移到首位 计算并打印进程的完成时刻、周转时间、带权周转时间 其中：周转时间 = 完成时间 - 到达时间 带权周转时间=周转时间/服务时间 更改计时器的当前时间,即下一刻进程的开始时间 当前时间=前一进程的完成时间+其服务时间 N 数组为空 Y 结束
先来先服务算法流程
文案大全
实用文档
2)时间片轮转法 开始输入进程总数输入各进程信息输出为就绪状态的进程的信息Y跳过已结束的程序输出此时为就绪状态的进程的信息Y指向下一个进程时间片轮转算法流程图
文案大全
NN指针所指的进程是否结束更改正在运行的进程的已运行时间如果存在下一个进程的话结束 实用文档
B.存储器管理(可变式分区管理） 1)首次适应法 分配流程图
开始 申请xkb内存 由链头找到第一个空闲区 小于 分区大小≥xkb？ 等于 大于 延链查找下一个空闲区 否 到链尾了？ 作业等待 是 分区大小=分区大小-xkb，修改下一个空闲区的后向指针内容为（后向指针）+xkb;修改上一个空闲区的前向指针为（前向指针）+xkb 将该空闲区从链中摘除：修改下一个空闲区的后向地址=该空闲区后向地址，修改上一个空闲区的前向指针为该空闲区的前向指针 返回 登记已分配表 返回分配给进程的内存首地址
文案大全
实用文档
首次适应算法回收流程图
文案大全
实用文档
开始 输入完成进程的标号 在分配区表中查找 释放区p下邻分区空释放区p上邻分区空 前一个空闲区的后向指针指向p的后一个分区，p的后一个分区的前向指针指向p的前一个分区，且p的前一个分区大小更改为加上p的大小，释放p 前一个分区的后向指针指向p的后一个空闲分区，p的后一个空闲分区的前向指针指向p的前一个分区，且p的后一个分区大小更改为加上p的大小 释放区p上下均邻空闲区 前一个空闲区的后向指针指向p的后一个空闲分区，p的后一个空闲分区的前向指针指向p的前一个空闲分区，且p的前一个空闲分区大小更改为加上p的大小再加上p的后一个空闲分区的大小，合并后的这个空闲区的后向指针指向p的下下个分区，如果p的下下个分区不为空，则其前向指针指向合并后的这个空闲区，释放p和p的下一个分区 释放区p上下均不邻空闲区 将p放在链首， 并修改其状态位为空闲
2）最佳适应法
文案大全
实用文档
回收内存流程 T 释放分区与下空闲分区相邻 开始 T 释放分区与上空闲分区相邻 F F 释放分区与下空闲分区相邻 F T 摘除链表中上下分区。合并这三个分区，将上空闲区长度修改为三个分区的长度。 摘除链表中上分区。合并释放分区与上分区，将上空闲区长度修改为这二分区的长度。 摘除链表中下分区。合并释放分区与下分区，将释放分区中长度修改为这二分区的长度。
C.虚拟存储器的缺页调度
文案大全
将合并的或释放的分区按长度升序重新插入到自由链表中。 结束 实用文档
1)先进先出FIFO
开始FIFO的缺页中断处理 查主存分块表
2）LRU
文案大全
有空闲块Y 可用？ 分配一块 N J=p[HEAD] N J的修改标志=1？ Y 输出“将J页复写入交换区” 输出“装入L页” 调整FIFO队列，将L插入队尾（HEAD=(HEAD+1)modM) 修改主存分块表和页表 终止 FIFO淘汰算法流程 实用文档
LRU淘汰算法流程 修改主存分块表和页表 调整堆栈，使HEAD所指元素及以下的元素下移P[HEAD]=L N J的修改标志=1？ Y 输出“将J页送到入交换区” 有空闲块可用？ N 找到栈底元素：J=p[M-1] Y 分配一块 开始LRU的缺页中断处理 查主存分块表 输出“装入L页” 终止
实现原理
文案大全
实用文档
主界面
设计一个框架分别去链接处理机管理、存储器管理和缺页调度相关的程序。
A.处理机调度
1)先来先服务FCFS （一）任务
先来先服务的调度算法实现处理机调度。 （二）要求
1.实现对FCFS算法的模拟实现
2.计算出该算法的平均作业周转时间、平均带权作业周转时间。 （三）原理
按作业到达CPU时间先后顺序进行非剥夺式调度，先到达CPU的作业先被执行。 （四）数据结构
struct task_struct {
char name; /*进程名称*/ int number; /*进程编号*/ float come_time; /*到达时间*/
float run_begin_time; /*开始运行时间*/ float run_time; /*运行时间*/ float run_end_time; /*运行结束时间*/ int priority; /*优先级*/ int order; /*运行次序*/ int run_flag; /*调度标志*/ }tasks[MAX];
int fcfs()/*先来先服务算法*/
进程名 链接指针 到达时间 估计运行时间 进程状态 进程控制块结构 （五）实现方法
建立一个链表按照到达CPU的时间从小到大排列，只需从第一个作业（头结点）依次调度到最后一个作业（尾结点）。
文案大全
实用文档
（六）运行界面 测试数据： 作业名 A B C 执行FCFS算法如下：到达时间 0 0 0 运行时间 28 9 3
2)时间片轮转法
（一）任务
只对进程的运行模拟，将其运行时间加一，判断要求运行时间与已运行时间是否相等，若相等则表示进程结束，进程退出调度，释放资源。 （二）要求
1.实现对RR算法的模拟实现
2.显示执行完一个时间片的结果。 （三）原理
时间片轮转算法中，系统将所有的就程序按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，调度程序停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。
（四）数据结构
temp->state='R'; //初始状态每个进程均为运行态 temp->allocation=0; //初始时进程均不占用cpu num+=temp->need_time; //用num来循环的次数 （五）实现方法
处理器调度总是选择标志单元指示的进程运行。执行：
已运行时间+1
来模拟进程的一次运行，表示进程已经运行过一个单位的时间。当一个进程被选中运行时，必须设置该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片
进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。同时，应判断该进程的要求运行时间与已运行时间，
文案大全
实用文档
若该进程的要求运行时间已运行时间，则表示它尚未执行结束，应待到下一轮时再运行。若该进程的要求运行时间=已运行时间，则表示它已经执行结束，应指导它的状态修改成“结束”且退出队列。此时，应把该进程的进程控制块中的指针值送到前面一个进程的指针位置。
进程名 链接指针 到达时间 估计运行时间 进程状态 进程控制块结构 （六）运行界面 测试数据： 作业号 执行时间/s A 1 B 2 C 1 执行时间片轮转算法RR如下：
B.存储器管理(可变式分区管理）
文案大全
实用文档
1)首次适应法 （一）任务
通过采用首次适应算法实现内存的分配与回收，并可以查看和显示当前内存现状。
（二）要求
1.实现对FF算法的模拟实现
2.输入要进行分配内存的进程ID和相应所需内存大小，回收内存时输入已运行的进程ID。 （三）原理
FF算法要求空闲链已地址递增的次序连接。分配内存时，从链首开始顺序查找，直到找到第一个满足要求的空间并分配给进程，把分配后余下的空间仍然留在链表中。若从链首至链尾都不满足要求，则分配失败。该算法倾向于优先使用低地址的空间。 （四）数据结构
int const MEMO=256;//初始化常类型MEMO，用MEMO表示内存大小（常类型的变量或对象的值是不能被更新的） struct FreeMemory {
int ID;int StartAdd;int Size; bool State;//定义state 为布尔型变量，其值只有 真 （TRUE) 和假 （FALSE) FreeMemory* Next; };
FreeMemory* AllocTable=new FreeMemory;//建立全局管理表用于内与回收 FreeMemory* PtrforCycleFit=AllocTable;//为循环首次适应定义的指针，此指针用于指向当前查找的起始地址;
//初始化内存函数
void MemoryInit(FreeMemory* &tempAdd) {
tempAdd->ID=0;//初始化当前进程为空
tempAdd->Size=MEMO;//初始化可分配空间为内存大小 tempAdd->StartAdd=0;//初始化起始地址为0 tempAdd->State=false;// 初始化状态为未分配 tempAdd->Next=NULL;//初始化下一个进程也为空 }
//反馈内存现态 void DispMemory() {
FreeMemory* temp=AllocTable;//全局管理表反映内存状态 cout<<\"系统总内存: \"< cout<<\"进程ID：\"< 文案大全 实用文档 地址:\"< 当一个作业执行完成时，作业所占用的分区应归还给系统。在归还时，要考虑相邻空间区合并问题。作业的释放区与空闲区的邻接分以下4种情况考虑： A、释放区下邻空闲区； B、释放区上邻空闲区； C、释放区上下都与空闲区邻接； D、释放区上邻空闲区不邻接。 （六）运行界面 系统总内存为256时，分别为进程1、2、3分配大小为、128、的内存。 执行首次适应算法分配内存如下： 若回收进程2的内存，执行结果如下： 2）最佳适应法 （一）任务 通过采用最佳适应算法实现内存的分配与回收，并可以查看和显示当前内存现状。 文案大全 实用文档 （二）要求 1.实现对BF算法的模拟实现 2.输入要进行分配内存的进程ID和相应所需内存大小，回收内存时输入需要回收的内存块。 （三）原理 最佳适应算法扫描整个未分配表或链表，从空闲区中挑选一个能满足用户进程要求的最小分区进行分配。此算法保证不会分割一个更大的区域，使得装入大作业的要求容易得到满足，同时，通常把空闲区按长度递增顺序排列，查找时总是从最小的一个空闲区开始，直至找到满足要求的分区为止，这时，最佳适应分配算法等同于首次适应算法。此算法的主存利用率好，所找出的分区如果最好满足要求则是最合适的。 （四）数据结构 int const MEMO=256;//初始化常类型MEMO，用MEMO表示内存大小（常类型的变量或对象的值是不能被更新的） struct FreeMemory { int ID;int StartAdd;int Size; bool State;//定义state 为布尔型变量，其值只有 真 （TRUE) 和假 （FALSE) FreeMemory* Next; }; bool Alloc_BestFit(int id,int TrySize) {//查找满足此条件的 x1<=TrySize<=x2 的分区,然后将其放置在x2中，并将x2拆分成两个分区 SortPartition(true);//使用快速排序算法，升序排序 for(;temp;temp=temp->Next) { /*回收操作,回收过程中，要用到三个指针，上一个Last,当前temp,下一个temp->next 当temp指向表头或表尾时需要特殊考虑*/ //当要退出工作时,就要回收//此退出的工作由执行函数调用 void EndJob(int id) { Free_Memory(id); } （五）实现方法 空闲区设置为双向链表，其双向链的分区格式为： 0（状态位） 分区大小（N+2） 向前指针 大小为N的已分配区或空闲区 0（状态位） 分区大小（N+2) 向后指针 （六）运行界面 测试数据如下： 进程 1 2 3 4 文案大全 5 6 实用文档 所需内存 25 34 45 执行最佳适应算法为其分配内存如下： 12 13 10 若回收进程4，执行结果如下： C.虚拟存储器的缺页调度 1)先进先出FIFO （一）任务 采用先进先出FIFO算法实现分页管理的缺页调度，并输出每次调入调出的页号和运行结果。 （二）要求 1.实现对FIFO算法的模拟实现 2.输出每次执行的结果。 （三）原理 基于程序总是按线性顺序来访问物理空间这一假设，总是淘汰最先调入主存的页面，即淘汰在主存中驻留时间最长的页面，认为驻留时间最长的页不再使用的可能性较大。 （四）数据结构 void FIFO(){ 文案大全 实用文档 int length; int fifo[100]={0}; int pageLength; int fifoPage[100]={0}; int i,j; cout<<\" ***********************先进先出**************************\"< if(flag==1) { } else { cout<<\" →淘汰\"< （五）实现方法 当采用先进先出算法时，用一个数组构成先进先出队列，数组中各个元素为进程已在主存的页号，其队列头指针初始化为0.假设分配给每个进程的内存块数固定。当队列满需淘汰时，淘汰最先进入主存的一页。若该页修改过，还有存入磁盘。然后要把当前访问的页装入该块，并修改页表和存储分块表的对应标志。 （六）运行界面 测试数据： 页表长度：9； 页框长度：3； 页面请求数列：4,4,3,5,1,1,2,3,2 执行先进先出FIFO算法结果如下： 文案大全 实用文档 2）LRU （一）任务 采用先进先出LRU算法实现分页管理的缺页调度，并输出每次调入调出的页号和运行结果。 （二）要求 1.实现对LRU算法的模拟实现 2.输出每次执行的结果。 （三）原理 文案大全 实用文档 最近最少使用页面替换算法淘汰的页面是在最近一段时间内最久未被访问的那一页，它是基于程序局部性原理来考虑的，认为那些刚被使用过的页面可能还有立即被使用，而那些在较长时间内未被使用的页面可能不会立即使用。在分页虚拟存储系统中，当硬件发出缺页中断后转操作系统处理缺页中断。如果主存中已无空闲块，可采用LRU算法进行缺页处理。 （四）数据结构 void LRU() { int length; int lru[100]={0}; int pageLength; int lruPage[100]={0}; int i,j; cout<<\" ***********************最***********************\"< 文案大全 近最少使用LRU算法→淘汰\"< } lruPage[1]=lru[i]; （五）实现方法 当采用LRU算法时，用一个数组构成堆栈，堆栈中各个元素为进程已在主存的页号，为了进行页面置换，可设置一个栈指针，初始化为0.假定分配给每个进程的内存块数固定不变。当队列满需淘汰时，操作系统选择栈底元素淘汰，其他元素向下移一个位置，将新调入页放栈指针指示的栈顶。当访问的页在栈中时，还应调整页从当前位置到栈顶。 （六）运行界面 测试数据： 页表长度：9； 页框长度：3； 页面请求数列：2,3,5,1,5,5,4,4,3 执行最近最少使用LRU算法结果如下： 文案大全 实用文档 总结与体会 通过本次课程设计让我对于图形界面设计有了一定的思路和看法，同时我对先来先服务、时间片轮转、首次适应算法、最佳适应算法、先进先出和最近最少使用算法有了更详尽的认识。在编程的过程中发现会用到大量的指针，用指针来操作大量的数据比较方便，但最后应该记得释放资源。从这次实验中我发现我对于c++掌握也有所不足，程序经过了多次修改才得以完善，在以后应该注重编程方面的训练。 此外我还更深入的理解了各个进程调度算法，及实现过程。在编写程序时查询了很多资料，间接提高了我的搜索能力。在此次课程设计过程中，对进程的相关知识有了一定的加深。特别是对进程的进程控制块的存在和价值有了更进一步的认识。在编写程序的过程之中，对进程自身信息的设计和管理以及调度的算法都有助于对书本知识的理解和掌握。特别是设计先来先服务调度算法和时间片轮转调度算法的时候，对进程的调度算法有了更好的深入理解。对进程管理中的等待队列，就绪队列，时间片等概念有了更深刻的印象。 在设计此模拟操作系统的课设中，也加深了对c++知识的把握。解决了一些以往在编程中遇到了困难。通过此次的课程设计，不仅提高了对操作系统的认知，也在同时提高了编程的能力，加强了实践。另外，我觉得此次课程设计虽然主要问题是在编程上，但是经过不断的去调试，还是成功的调试了出来。但是这几个程序用了多天的时间进行分析和修改，虽然出现了不少问题，但收获颇多！ 文案大全 实用文档 源代码： #include int fcfsoutput(); /*调度结果输出*/ int fcfsinput(); //进程参数的初始化 void kaishi(); #define MAX 10 struct node //建立链表来存放进程数据 { char name[5]; //进程名称 int need_time; //所需要的时间 int allocation; //占用cpu的情况 char state; //目前的状态 R为运行，E为运行完毕 node *next; //链表的尾结点 }; struct task_struct { char name; /*进程名称*/ int number; /*进程编号*/ float come_time; /*到达时间*/ float run_begin_time; /*开始运行时间*/ float run_time; /*运行时间*/ float run_end_time; /*运行结束时间*/ int priority; /*优先级*/ int order; /*运行次序*/ int run_flag; /*调度标志*/ }tasks[MAX]; int counter; /*实际进程个数*/ int fcfs()/*先来先服务算法*/ { fcfsinput(); float time_temp=0; int i; int number_schedul; time_temp=tasks[0].come_time; for(i=0;i tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_time; 文案大全 实用文档 tasks[i].run_flag=1; time_temp=tasks[i].run_end_time; number_schedul=i; tasks[number_schedul].order=i+1; } fcfsoutput(); return 0; } int fcfsinput() { task_struct tt; int i,j; //初始化进程数 counter=3; //初始化每个到达系统的时间为5、7、8 tasks[0].come_time=rand()%9; tasks[1].come_time=rand()%9; tasks[2].come_time=rand()%9; for(i=1;i<3;i++) { for(j=0;j<3-i;j++) { if(tasks[j].come_time>tasks[j+1].come_time) { tt=tasks[j]; tasks[j]=tasks[j+1]; tasks[j+1]=tt; } } } //初始化每个进程估计运行的时间 tasks[0].run_time=28; tasks[1].run_time=9; tasks[2].run_time=3; //初始化每个进程的名字 tasks[0].name='A'; tasks[1].name='B'; tasks[2].name='C'; 文案大全 实用文档 cout<<\"************************先来先服务算法************************\"< return 0; } int fcfsoutput() /*调度结果输出*/ { int i; float turn_round_time=0,f1,w=0; cout<<\"作业名 到达时间 运行时间 开始时间 停止时间 运行次序 周转时间\"< cout<<\" \"< /*-------------------------------------------------------------------------------------*/ int rr() { int n=3,num=0; node *head=NULL; node *tail=NULL; cout<<\"*********************时间片轮转调度算法*********************\"< 实用文档 node *temp=new node; if(i==0)strcpy(temp->name,\"A\"); if(i==1)strcpy(temp->name,\"B\"); if(i==2)strcpy(temp->name,\"C\"); temp->need_time=rand()%4+1; temp->state='R'; //初始状态每个进程均为运行态 temp->allocation=0; //初始时进程均不占用cpu num+=temp->need_time; //用num来循环的次数 if(!head) { tail=head=temp; } else { tail->next=temp; tail=temp; tail->next=head; } } node *p; p=head; cout< cout<<\" \"< while(label==1&&m<=num) { cout< 文案大全 实用文档 if(p->need_time) { p->need_time--; p->allocation++; if(p->need_time==0) { p->state='E'; } label=1; p=p->next; } cout<<\"执行\"< cout<<\" \"< int const MEMO=256;//初始化常类型MEMO，用MEMO表示内存大小（常类型的变量或对象的值是不能被更新的） struct FreeMemory { int ID;int StartAdd;int Size; bool State;//定义state 为布尔型变量，其值只有 真 （TRUE) 和假 （FALSE) FreeMemory* Next; }; 文案大全 实用文档 FreeMemory* AllocTable=new FreeMemory;//建立全局管理表用于内存分配与回收 FreeMemory* PtrforCycleFit=AllocTable;//为循环首次适应定义的指针，此指针用于指向当前查找的起始地址; //初始化内存函数 void MemoryInit(FreeMemory* &tempAdd) { tempAdd->ID=0;//初始化当前进程为空 tempAdd->Size=MEMO;//初始化可分配空间为内存大小 tempAdd->StartAdd=0;//初始化起始地址为0 tempAdd->State=false;// 初始化状态为未分配 tempAdd->Next=NULL;//初始化下一个进程也为空 } //反馈内存现态 void DispMemory() { FreeMemory* temp=AllocTable;//全局管理表反映内存状态 cout<<\"系统总内存: \"< cout<<\"进程ID：\"< void SortPartition(bool order)//在此使用的是快速排序算法 { FreeMemory* temp1=AllocTable; FreeMemory* temp2=AllocTable; FreeMemory* Last1=temp1; FreeMemory* Last2=temp2; if(temp2->Next) temp2=temp2->Next; switch(order) { case 1://升序部分 { for(;temp1;temp1=temp1->Next) { for(;temp2;temp2=temp2->Next) { if((temp1->Size> temp2->Size)&&!temp1->State&&!temp2->State)//找到符合条件的，则交换 文案大全 实用文档 { Last1->Next=temp2; Last2->Next=temp1; FreeMemory* temp=temp2->Next; temp2->Next=temp1->Next; temp1->Next=temp->Next; } Last2=temp2; } Last1=temp1; } } break; case 0://降序部分 { for(;temp1;temp1=temp1->Next) { for(;temp2;temp2=temp2->Next) { if((temp1->Size < temp2->Size)&&!temp1->State&&!temp2->State)//找到符合条件的，则交换 { Last1->Next=temp2; Last2->Next=temp1; FreeMemory* temp=temp2->Next; temp2->Next=temp1->Next; temp1->Next=temp->Next; } Last2=temp2; } Last1=temp1; } } } } /*内存分配*/ bool Alloc_FirstFit(int id, int TrySize)// 定义布尔型函数Alloc_FirstFit() { //查找一个可用第一个满足分配请求的分区，如果满足将其写入内存分配表 文案大全 实用文档 //否则分配失败，返回 FreeMemory* temp=AllocTable; for(;temp;temp=temp->Next) { if(TrySize<=temp->Size && !temp->State)//第一个满足条件的分区已找到 { if(TrySize==temp->Size)//刚好和申请的大小一致 { temp->ID=id; //保持不变temp->Next,Size,StartAdd都不用变 temp->State=true; //值为真表示已分配 } else//比所找到的要小，则需要将其拆分 { FreeMemory* NewItem=new FreeMemory; NewItem->Next=temp->Next; NewItem->ID=0; NewItem->Size=temp->Size-TrySize; NewItem->StartAdd=temp->StartAdd+TrySize; NewItem->State=false; temp->ID=id; temp->Size=TrySize; temp->State=true; temp->Next=NewItem; } return true; } }//end for return false; } bool Alloc_BestFit(int id,int TrySize) {//查找满足此条件的 x1<=TrySize<=x2 的分区,然后将其放置在x2中，并将x2拆分成两个分区 SortPartition(true);//使用快速排序算法，升序排序 FreeMemory* temp=AllocTable; if(temp->Next) temp=temp->Next; for(;temp;temp=temp->Next) { if(TrySize<=temp->Size && !temp->State)//第一个满足条件的分区已找到 { if(TrySize==temp->Size)//刚好和申请的大小一致 文案大全 实用文档 { temp->ID=id; //保持不变temp->Next,Size,StartAdd都不用变 temp->State=true; //值为真表示已分配 } else//比所找到的要小，则需要将其拆分 { FreeMemory* NewItem=new FreeMemory; NewItem->Next=temp->Next; NewItem->ID=0; NewItem->Size=temp->Size-TrySize; NewItem->StartAdd=temp->StartAdd+TrySize; NewItem->State=false; temp->ID=id; temp->Size=TrySize; temp->State=true; temp->Next=NewItem; } return true; } }//end for return false; } bool Alloc_Memory(int id, int Algorithm,int TrySize)//对算法进行选择 { switch(Algorithm) { case 1 : return Alloc_FirstFit(id,TrySize); break; case 2: return Alloc_BestFit(id,TrySize); break; default: cout<<\"你没有指定算法,系统将默认为首次适应算法!!!\"< 文案大全 实用文档 /*Recycle Memory 回收内存*/ bool Free_Memory(int id) { FreeMemory* temp=AllocTable; FreeMemory* Last=temp; if(temp->ID==id) { //考虑第一条记录的特殊情况 if(temp->Next && !temp->Next->State)//下一分区没有被占用，将与本条合并 { temp->ID=0; temp->Size=temp->Size+temp->Next->Size; temp->State=0;//回收 Last=temp->Next; temp->Next=temp->Next->Next; delete Last; } else//只有第一分区为空，则清除相关表项的数据 { temp->ID=0; temp->State=false;//改为没有使用状态 } return true; } //特殊情况第一条 if(temp->Next) temp=temp->Next; for(;temp;temp=temp->Next) { /*回收操作,回收过程中，要用到三个指针，上一个Last,当前temp,下一个temp->next 当temp指向表头或表尾时需要特殊考虑*/ if(temp->ID==id)//begin 找到该ID表项 { if(temp->Next)//没有到最后一条 { if(!Last->State&&!temp->Next->State)//回收区与插入点的前、后两个分区邻接 优先级为 1 { Last->Next=temp->Next->Next; Last->Size=Last->Size+temp->Size+temp->Next->Size; delete temp->Next; delete temp; }else if(!Last->State)//回收区与插入点的前一个分区相邻接 优先级为2 文案大全 实用文档 { Last->Next=temp->Next; Last->Size=Last->Size+temp->Size; delete temp; }else if(!(temp->Next->State))// 回收区与插入点的后一个分区相邻接 优先级为3 { //if(temp->Next->Next) Last=temp->Next->Next; //else // Last=NULL; temp->Size=temp->Size+temp->Next->Size; temp->State=false; temp->ID=0; FreeMemory* tempfor=temp->Next; temp->Next=Last; delete tempfor; } else// 回收区为单位. 优先级为4 { temp->ID=0; temp->State=false; } }//最后一条 else { if(!Last->State)//最后一条的前一条为空 { Last->Size=Last->Size+temp->Size; Last->Next=NULL; delete temp; } else//最后一条的前一条不为空 { temp->ID=0; temp->State=0; } } return true; }//end 找到该ID表项 此类情况处理完毕 Last=temp; }//endfor return false; } 文案大全 实用文档 /*Memory Recycled 内存分配完毕 All done ,the job refered will leave system */ //当进程开始时,就应该为之分配内存 void BeginJob(int id,int Algorithm,int TrySize) { Alloc_Memory(id,Algorithm,TrySize); } //当要退出工作时,就要回收//此退出的工作由执行函数调用 void EndJob(int id) { Free_Memory(id); } /*--------------------------------------------------------------------------------*/ void FIFO(){ int length; int fifo[100]={0}; int pageLength; int fifoPage[100]={0}; int i,j; cout<<\" ***********************先**************************\"< 进先算法 出实用文档 for(j=1;j<=pageLength;j++){ if(fifo[i]==fifoPage[j]){ flag=1; j=pageLength+1; }else if(fifoPage[j]==0){ fifoPage[j]=fifo[i]; j=pageLength+1; flag=1; } } if(flag==1) { } else { cout<<\" →淘汰\"< 文案大全 实用文档 int lruPage[100]={0}; int i,j; cout<<\" ***********************最***********************\"< 文案大全 近最少使用LRU算法→淘汰\"< int cunchuqi() { MemoryInit(AllocTable);//初始化 int Way; while(true) { cout<<\"请输入你所选择的算法:\\r\\n\\ 1.首次适应\\r\\n\\ 2.最佳适应\"< 实用文档 cout<<\"请输入:\"; cin >> Way; if(Way>0&&Way<=2)//选择的序号只有1,2 break;//跳出while循环 cout<<\"你的输入不正确，请重新输入！\"< int choice; cout<<\"操作选择：\\r\\n\\ 0 Exit\\r\\n\\ 1 分配内存\\r\\n\\ 2 回收内存\\r\\n\\ 3 显示内存现状\\r\\n\"< if(choice<0||choice>3) {cout<< \"操作选择有误重新输入\"< cout<<\"请输入进程ID：\"< cout<<\"请输入进程所需大小：\"< BeginJob(id,Way,size); } else if(choice==2) { int id; cout<<\"请输入进程ID:\"< }else if(choice==0)//Exit; { break; }else //显示内存现状 { DispMemory(); 文案大全 实用文档 } } return 1; } void queye() { int n; cout< void kaishi() { cout< 实用文档 } 文案大全 因篇幅问题不能全部显示，请点此查看更多更全内容
Copyright © 2019- bangwoyixia.com 版权所有 湘ICP备2023022004号-2
违法及侵权请联系：TEL:199 1889 7713 E-MAIL:2724546146@qq.com
本站由北京市万商天勤律师事务所王兴未律师提供法律服务