综合实验报告
( 20##-- 20##年度第六学期)
名 称：操作系统原理综合实验B
题 目：小型仿真操作系统的设计
院 系：
班 级：
学 号：
学生姓名：
指导教师：
设计周数： 一周
成 绩：
日期：
实验一：单处理器系统的进程调度
1．实验目的
在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。
2．实验内容与要求
（1）设计多个进程并发执行的模拟调度程序，每个程序由一个PCB表示。
（2）模拟调度程序可任选两种调度算法之一实现。
（3）程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。
3．实验原理
建立进程循环链表，进程信息包括进程名和需要运行的时间，每次运行一次，系统的运行时间加1，当运行到所需时间时将其状态设为1，说明此进程运行完毕，删除此进程，直到所有进程都运行完毕。
4．实验源程序
#include <iostream.h>
#include <stdio.h>
#define NULL 0
int Name[5]={'1','2','3','4','5'};
struct PCB
{
char name;//PCB名字
int RunTime;//PCB已运行时间
int RequestTime;//PCB要求运行时间
char status;//PCB状态
struct PCB* head;//指向上一个PCB结构体的指针变量
struct PCB* next;//指向下一个PCB结构体的指针变量
};
struct PCB pcb1,pcb2,pcb3,pcb4,pcb5,*p,*q;
////定义PCB各参数的初值，输入各个进程的运行时间
Value()
{
pcb1.name=Name[0];
pcb2.name=Name[1];
pcb3.name=Name[2];
pcb4.name=Name[3];
pcb5.name=Name[4];
///定义PCB状态，初态为'R'
pcb1.status='R';
pcb2.status='R';
pcb3.status='R';
pcb4.status='R';
pcb5.status='R';
///定义PCB运行时间，初值为0
pcb1.RunTime=0;
pcb2.RunTime=0;
pcb3.RunTime=0;
pcb4.RunTime=0;
pcb5.RunTime=0;
///给PCB的要求运行时间赋值
cout<<endl;
cout<<"请给各个PCB的要求运行时间赋值(int):"<<endl;
cout<<"第一个PCB "<<pcb1.name<<"要求运行的时间为：";
cin>>pcb1.RequestTime;
cout<<"第二个PCB "<<pcb2.name<<"要求运行的时间为：";
cin>>pcb2.RequestTime;
cout<<"第三个PCB "<<pcb3.name<<"要求运行的时间为：";
cin>>pcb3.RequestTime;
cout<<"第四个PCB "<<pcb4.name<<"要求运行的时间为：";
cin>>pcb4.RequestTime;
cout<<"第五个PCB "<<pcb5.name<<"要求运行的时间为：";
cin>>pcb5.RequestTime;
return 0;
}
///////////使PCB连接成循环队列
Connect()
{
///////PCB的前驱
pcb1.head=&pcb5;
pcb2.head=&pcb1;
pcb3.head=&pcb2;
pcb4.head=&pcb3;
pcb5.head=&pcb4;
////////PCB的后续
pcb1.next=&pcb2;
pcb2.next=&pcb3;
pcb3.next=&pcb4;
pcb4.next=&pcb5;
pcb5.next=&pcb1;
return 0;
}
///////显示输入
display()
{
cout<<"----------------------------------------------------------------"<<endl;
cout<<" 进程名称 "<<" 下一进程名"<<" 运行时间";
cout<<" 要求时间"<<" 状态"<<endl;
cout<<"----------------------------------------------------------------"<<endl;
return 0;
}
/////PCB执行
Run()
{
Value();
Connect();
// struct PCB pcb1,pcb2,pcb3,pcb4,pcb5,*p,*q;
char a;
int num,n,PcbNum=5,Number=5,flag=1;//PcbNum表示进程执行过程中进程的个数，n表示已执行完毕的进程个数
q=NULL; //flag=1时程序继续
cout<<endl;
cout<<"请选择你想要运行的进程：";
cin>>num;
cout<<endl;
switch(num)//num为何值则转向那一个case，选择执行的进程
{
case 1:
p=&pcb1;
break;
case 2:
p=&pcb2;
break;
case 3:
p=&pcb3;
break;
case 4:
p=&pcb4;
break;
case 5:
p=&pcb5;
break;
}
while (flag==1){
n=1;
if((p->RequestTime==0)||(p->RequestTime==p->RunTime))
{///要求运行时间为0或要求运行时间＝运行时间时status＝'E'
p->status='E';
}
else
{ //否则，运行时间＋1
p->RunTime=p->RunTime+1;
}
cout<<"进程运行情况如下所示："<<endl<<endl;
cout<<"当前正在执行的进程名称为："<<p->name<<endl<<endl;
display();
while(n<=PcbNum){
if((p->RequestTime==0)||(p->RequestTime==p->RunTime))
{///要求运行时间为0或要求运行时间＝运行时间时status＝'E'
p->status='E';
}
cout<<"\t"<<p->name<<"\t "<<p->next->name<<"\t "<<p->RunTime<<"\t "<<p->RequestTime;
cout<<"\t "<<p->status<<endl;
cout<<"----------------------------------------------------------------"<<endl;
cout<<endl;
if ((p->RunTime==p->RequestTime)&&(n==1)){/////该进程执行完毕
q=p;
Number=Number-1;
}
p=p->next;//指向下一进程
n++;
PcbNum=Number;
}
if(q!=NULL){
if(q->RunTime==q->RequestTime){//有一个进程块执行完毕
q->status='E';
q->head->next=q->next;
q->next->head=q->head;
cout<<"-----------------进程"<<q->name<<"已执行完毕!-----------------"<<endl<<endl;
p=q->next;
q=p;
}
else{
p=p->next;
}
}
if(q==NULL){
p=p->next;
}
if(PcbNum!=0){
flag=0;
cout<<"----要继续运行程序请按Enter键两次----"<<endl;
a=getchar();
if(a==getchar()){
flag=1;
}
else{
cout<<"输入错误!"<<endl;
cout<<"--------------------------- 程序结束！---------------------------"<<endl;
flag=0;
}
}
if(PcbNum==0){
flag=0;
cout<<"--------------------------进程经已全部执行完毕!-------------------------"<<endl;
}
}
return 0;
}
main()
{
Run();
return 0;
}
5．实验结果
6．实验结论与总结
本实验基本达到了实验目的。
通过本次实验，我进一步熟悉了时间片轮转法进行进程调度，本次实验实现比较简单，只要实现每运行一次，运行时间加1，进行下一个进程，当运行时间达到要求服务时间时，进程运行结束，从链表中删除该进程，实验时并无太大的困难，比较简单的实现了，最后，感谢老师耐心的指导。
实验二：批处理系统中作业调度
1．实验目的
加深对作业调度算法的理解。
2．实验内容
此实验模拟批处理系统中的作业调度，并采用响应比高者优先算法作为作业调度算法。
3．实验原理
实验采用最高响应比算法实现对作业的调度，响应比为作业的等待时间和作业估计执行时间之比。在不断调用进程的过程中，作业的响应比动态变化。
输入作业数量，输入作业信息，用数组储存，当达到设置的作业数量时，输入结束，依次判断每个作业是否满足条件，满足的话在进行下面的运算，在第一次作业调度时，找到到达时间最早的那个作业，输出，若不止一个最早，就调度第一个最早到达的。然后修改系统运行时间和每个作业的相关信息，用flag进行标记，当flag为0时表示作业仍未到达，当为1时，表示作业等待，flag=2时，作业调度完。执行多次操作，知道作业全部调度完为止。
4．实验源程序
#include <iostream>
#include<stdlib.h>
#include<string>
using namespace std;
#define max 100
struct jcb
{
string name; /*作业名*/
int length; /*作业长度，所需主存大小*/
int printer; /*作业执行所需打印机的数量*/
int tape; /*作业执行所需磁带机的数量*/
int runtime; /*作业估计的执行时间*/
int waittime; /*作业在输入井中的等待时间*/
int reachtime;
int flag;
}JCB[max]; /*作业控制块类型定义*/
int tape,printer;
int memory;
int n,w;
static systemruntime=0;
void input( )//创建进程,等待时间/执行时间响应比高
{
int c;
n=0;
cout<<"输入作业个数："<<endl;
cin>>c;
while(c!=0)
{
cout<<"作业名： ";
cin>>JCB[n].name;
cout<<"作业长度（MB）: ";
cin>>JCB[n].length;
cout<<"需打印机： ";
cin>>JCB[n].printer;
cout<<"需磁带机: ";
cin>>JCB[n].tape;
cout<<"到达时间： ";
cin>>JCB[n].reachtime;
cout<<"运行时间： ";
cin>>JCB[n].runtime;
JCB[n].flag =0;
JCB[n].waittime =0;
n++;
c--;
}
}
void judge()
{
w=0;
for(int j=0;j<n;j++)
{
if(JCB[j].length<=memory&&JCB[j].printer<=printer&&JCB[j].tape<=tape)
{
JCB[w].name=JCB[j].name;
JCB[w].length=JCB[j].length;
JCB[w].printer=JCB[j].printer;
JCB[w].tape=JCB[j].tape;
JCB[w].reachtime=JCB[j].reachtime;
JCB[w].runtime=JCB[j].runtime;
JCB[w].flag=JCB[j].flag;
JCB[w].waittime=JCB[j].waittime;
w=w+1;
}
}
n=w;
}
void output()
{
cout<<" 作业相关信息"<<endl;
cout<<"作业名"<<"\t"<<"作业长度"<<"\t"<<"打印机"<<"\t"<<"磁带机"<<"\t"<<"到达时间"<<"\t"<<"运行时间"<<endl;
for(int i=0;i<n;i++)
cout<<JCB[i].name <<"\t"<<JCB[i].length <<"\t\t"<<JCB[i].printer <<"\t"<<JCB[i].tape <<"\t"<<JCB[i].reachtime <<"\t\t"<<JCB[i].runtime <<endl;
}
void hrrn()
{
int waittime;
int mintime;/*最早到达时间*/
int q=0;
int k,i,j;
int runtime;
double hrrf;
mintime=JCB[0].reachtime ;
for(i=1;i<n;i++)//判断最早到达的作业
if(JCB[i].reachtime <mintime) mintime=JCB[i].reachtime ;
for(i=0;i<n;i++)
if(JCB[i].reachtime ==mintime)
{
cout<<JCB[i].name <<" ";
JCB[i].flag =2;
for(j=0;j<n;j++)
{
if(j==i)continue;
if(JCB[j].reachtime<=JCB[i].reachtime +JCB[i].runtime )//作业正在执行时，有作业到达
{
JCB[j].waittime=JCB[i].reachtime+JCB[i].runtime-JCB[j].reachtime ;//等待时间
JCB[j].flag =1;
}
}
runtime=JCB[i].reachtime +JCB[i].runtime;//系统的执行时间
break;
}
k=1;
while(k<n)
{
for(i=0;i<n;i++)
if(JCB[i].flag ==1)//等待状态中的作业
{
hrrf=(JCB[i].waittime+JCB[i].runtime) /JCB[i].runtime ;//i的响应比计算，i是第一个状态值为1的
break;
}
for(j=i+1;j<n;j++)//寻找响应比最高的作业
if((JCB[j].flag==1)&&(((JCB[j].waittime+JCB[j].runtime) /JCB[j].runtime) >hrrf))
{
hrrf=(JCB[j].waittime+JCB[j].runtime) /JCB[j].runtime;
q=j;
}
if(q!=0)//有响应比i作业的响应比高的作业
{
cout<<JCB[q].name <<" ";
JCB[q].flag =2;
runtime+=JCB[q].runtime ;
}
else//没有比i响应比更高的
{
cout<<JCB[i].name <<" ";
JCB[i].flag =2;
runtime+=JCB[i].runtime ;
}
q=0;
for(i=0;i<n;i++)
{
if(i==q)continue;
if(JCB[i].flag ==2) continue;
else if(JCB[i].flag ==1)
JCB[i].waittime +=JCB[q].runtime ;
else
{
if(JCB[i].reachtime <=runtime)
{
JCB[i].flag =1;
JCB[i].waittime =runtime-JCB[i].reachtime ;
}}}
k++;
}}
void main()
{
cout<<"系统资源情况:"<<endl;
cout<<"主存大小(MB):";
cin>>memory;
cout<<"打印机台数： ";
cin>>printer;
cout<<"磁带机台数: ";
cin>>tape;
input();
judge();
output();
cout<<"作业输出序列为："<<endl;
hrrn();
cout<<endl;
}
5．实验结果
6．实验结论与总结
本实验基本达到了实验目的。
我所设计的本实验实现的功能比较简单，通过本实验，我进一步熟悉掌握了高响应比的算法原理，而且我设计的实验每次只处理一个作业，只要有作业执行时其他作业到达就是等待状态，由于我所实现的功能比较简单，因此在实现上也没有遇到太大的问题，一些小问题都在老师和同学的帮助下解决了，比较顺利的完成了本次实验，最后，感谢老师耐心的指导。
实验三：银行家算法
1． 实验目的和要求
银行家算法是避免死锁的一种重要方法，要求编写和调试一个简单的银行家算法程序。加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
2． 实验内容
1）设计进程对各类资源最大申请表示及初值确定。
2）设定系统提供资源初始状况。
3）设定每次某个进程对各类资源的申请表示。
4）编制程序，依据银行家算法，决定其申请是否得到满足。
3．实验原理
银行家算法
设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。
(1)如果Request[N]<=NEED[I，N]，则转(2)；否则，出错。
(2)如果Request[N]<=AVAILABLE，则转(3)；否则，出错。
(3)系统试探分配资源，修改相关数据：
AVAILABLE=AVAILABLE-REQUEST
ALLOCATION=ALLOCATION+REQUEST
NEED=NEED-REQUEST
(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
3．安全性检查
(1)设置两个工作向量WORK=AVAILABLE；FINISH[M]=FALSE
(2)从进程集合中找到一个满足下述条件的进程，
FINISH[i]=FALSE
NEED<=WORK
如找到，执行(3)；否则，执行(4)
(3)设进程获得资源，可顺利执行，直至完成，从而释放资源。
WORK=WORK+ALLOCATION
FINISH=TRUE
GO TO 2
(4)如所有的进程Finish[M]=true，则表示安全；否则系统不安全。
根据题意，建立M个进程，每个进程有N个资源数，用单链表实现，初始化进程信息，编制安全序列检查函数，在主函数中判断请求是否合理，若合理进行试探性分配，调用安全序列检查函数。安全性检查时，控制循环执行的次数为M次，若有一次的序列无法分配，则退出，提示不存在安全序列。若存在，打印序列。
4．实验源程序
#include <iostream.h>
#include <string.h>
#include <stdlib.h>
#define M 5 //总进程数
#define N 3 //总资源数
//M个进程对N类资源最大资源需求量
int MAX[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
//系统可用资源数
int AVAILABLE[N]={3,3,2};
//M个进程已经得到N类资源的资源量
int ALLOCATION[M][N]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
//M个进程还需要N类资源的资源量
int NEED[M][N]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};
typedef struct source
{
char name[4];//进程名
int Max[N];//进程所需最大资源
int Allocation[N];//进程已有资源
int Need[N];//进程还需资源
int Finish;//是否有足够的资源分配给进程
int Request[N];//进程请求资源
struct source *next;
}source;
source *head;
source *input(source *head)
{
source *p,*q;
for(int i=0;i<M;i++)
{
p=new source;
cout<<"请输入进程名：";
cin>>p->name;
for(int j=0;j<N;j++)
{
p->Max[j]=MAX[i][j];p->Allocation[j]=ALLOCATION[i][j];
p->Need[j]=NEED[i][j];p->Finish=0;p->Request[j]=0;
}
if(i==0) head=p;//头指针指向第一个资源
else q->next=p;q=p;
}
q->next=0;
return head;//返回头指针
}//建立链表并给给进程赋值
//资源状况的输出函数
void output(source *head)
{
source *p;
p=head;
cout<<"当前各进程资源情况"<<endl;
cout<<"--------------------------------------------------------------------------------"<<endl;
cout<<"进程"<<"\t"<<" MAX"<<"\t"<<" Allocation"<<"\t"<<" Need"<<"\t"<<" Available"<<"\t"<<endl;
cout<<" "<<p->name<<" ";
for(int i=0;i<N;i++)
cout<<p->Max[i]<<" ";cout<<"\t";
for( i=0;i<N;i++)
cout<<p->Allocation[i]<<" ";cout<<"\t";
for( i=0;i<N;i++)
cout<<p->Need[i]<<" ";cout<<"\t";
for( i=0;i<N;i++)
cout<<AVAILABLE[i]<<" ";cout<<endl;
for(p=head->next;p!=0;p=p->next)
{
cout<<" "<<p->name<<" ";
for(int i=0;i<N;i++)
cout<<p->Max[i]<<" ";cout<<"\t";
for( i=0;i<N;i++)
cout<<p->Allocation[i]<<" ";cout<<"\t";
for( i=0;i<N;i++)
cout<<p->Need[i]<<" ";cout<<"\t";
cout<<endl;
}
cout<<"-----------------------------------------------------------------------------"<<endl;
}
void secure(source *head,source *s)
{
source *x,*y;
int j,Work[N];//工作向量Work
int flag,tt=0;
cout<<"进行安全序列检查"<<endl;
for(int i=0;i<N;i++) Work[i]=AVAILABLE[i];
for(tt=0;tt<M;tt++)
{
flag=0;
y=head;
while((y!=0)&&(flag!=N))
{
flag=0;
while(y->Finish==1) y= y->next ;//一个进程执行完成 指针指向下一个进程
for( int i=0;i<N;i++)
if( y->Need[i]<=Work[i]) flag++;
x=y;
y=y->next;
}
if(flag!=N)//可用资源小于进程所需资源
{
for(int i=0;i<N;i++)
{
AVAILABLE[i]+=s->Request[i];
s->Allocation[i]-=s->Request[i];
s->Need[i]+=s->Request[i];
}
cout<<"不存在安全序列，不可分配资源"<<endl;
return;
}
else//执行进程
{
cout<<x->name <<" ";
for(i=0;i<N;i++) Work[i]+= x->Allocation[i];
x->Finish=1;
}
}
cout<<"存在安全序列"<<endl;
cout<<endl;output(head);
for(y=head;y!=0;y=y->next) y->Finish =0;
}
void main()
{
int flag1,flag2,flag3;
source *p,*s;
char name[4];
head=input(head);
output(head);
cout<<"申请资源的进程名，若不需申请，输入$:"<<endl;
cin>>name;
while((strcmp(name,"$"))!=0)//字符比较
{ flag3=-1;
flag1=flag2=0;
p=head;
while((p!=0)&&(strcmp(p->name,name)!=0)) p=p->next;
if(p==0) { cout<<"无此进程"<<endl; flag3=0;}
else
{s=p;cout<<s->name<<endl ;
cout<<"输入所需三类资源值："<<endl;
for(int i=0;i<N;i++) cin>>s->Request[i];
for( i=0;i<N;i++) if(s->Request[i]<=s->Need[i]) flag1+=1;//判断条件一
if(flag1!=N)
{cout<<"ERRORS!!资源请求过大"<<endl;
for(i=0;i<N;i++) s->Request[i]=0;flag3=0;flag1=0;
}
else
{
for( i=0;i<N;i++) if(s->Request[i]<=AVAILABLE[i]) flag2+=1;//判断条件二
if(flag2!=N) {cout<<"系统无足够资源"<<endl;flag2=0; flag3=0;}
else//可满足请求，进行资源分配
{
for(i=0;i<N;i++)
{
AVAILABLE[i]-=s->Request[i];
s->Allocation[i]+=s->Request[i];
s->Need[i]-=s->Request[i];
}
flag3=1;
}
}
}
if(flag3==1) secure(head,s); //分配后进行安全序列检测
cout<<"申请资源的进程名，若不需申请，输入$:"<<endl;
cin>>name;
}
}
5.实验结果
6．实验结论与总结
本次实验基本达到了实验目的。
通过本次实验，我更加深刻的掌握了新行家算法的原理和执行过程，本次实验主要的难点在于实现银行家算法的执行过程，主要是实现循环查找，使用链表实现，顺序查找，在这个程序实现时出现了一点儿问题，循环链表执行时出现了一点儿小问题，通过老师的指导和同学的帮助，逐渐解决了这个问题，但是程序只能找到一个安全序列，并不能把多个安全序列都找出来，算是基本实现了此次试验，最后感谢老师耐心的指导。
实验四：主存储器空间的分配和回收
1．实验目的
一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。主存的分配和回收的实现虽与主存储器的管理方式有关的，通过本实验帮助学生理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。
2．实验内容
本实验模拟在两种存储管理方式下的主存分配和回收。
3．实验原理
最先适应算法要求按照作业的需要量，查空闲区说明表，顺序查看登记栏，找到第一个能满足要求的空闲区。当空闲区大于需要量时，一部分用来装入作业，另一部分仍为空闲区登记在空闲区说明表中。在主函数中初始化内存分配，编写内存分配和回收函数，分配时，根据申请作业的大小和内存空间的分配情况，采用最先适应算法，找到合适的进行分配，回收作业时，若无足够的空表目登记，则退出，否则，若回收作业与空闲区上邻或下邻，要合并空闲区。
4．实验源程序
#include<iostream.h>
#include<stdlib.h>
#include<string.h>
#define m 5
#define n 10
struct
{
int first;
int length;
int flag;
}Vblock[m],A[m];
struct
{
int first;
int length;
char name[20];
}Cblock[n],B[n];
void print()
{
cout<<"____________________________________________________"<<endl;
cout<<" 起址 长度 状态 "<<endl;
for(int i=0;i<m;i++)
{
if(Vblock[i].flag==1)
{
cout<<"\t"<<Vblock[i].first<<"K"<<"\t"<<"\t"<<Vblock[i].length<<"K"<<"\t"<<" 未分配 "<<endl;
}
else if(Vblock[i].flag==0)
{
cout<<"\t\t"<<"\t\t"<<" 空表目 "<<endl;
cout<<"____________________________________________________"<<endl;
}
}
}
void request()
{
int len,k;
char name[20];
cout<<"输入申请的作业名：";
cin>>name;
cout<<"输入申请的作业大小：";
cin>>len;
for(int i=0;i<m;i++)
if(Vblock[i].length>=len)
{
for(int j=0;j<n;j++)
if(Cblock[j].length==0)break;
Cblock[j].first=Vblock[i].first;
Cblock[j].length=len;
strcpy(Cblock[j].name,name);
Vblock[i].first+=len;
Vblock[i].length-=len;break;
}
if(i==m) {cout<<"无足够空间分配，退出"<<endl;return;}
if(Vblock[i].length==0)
{
for( k=i+1;k<m;k++)
{ A[k].length=Vblock[k].length;
A[k].first=Vblock[k].first;
A[k].flag=Vblock[k].flag;
}
for(k=i;k<m-1;k++)
{
Vblock[k].first=A[k+1].first;
Vblock[k].length=A[k+1].length;
Vblock[k].flag=A[k+1].flag;
}
Vblock[m-1].first=0;
Vblock[m-1].length=0;
Vblock[m-1].flag=0;
}
cout<<"作业"<<name<<"已分配"<<endl;
}
void freeblock()
{
int t=0,w=0,k,j,ww,kk;
char name[20];
cout<<"输入将回收的作业名:";
cin>>name;
while((t!=n)&&(strcmp(Cblock[t].name,name)!=0)) t++;//Cblock[t]为待撤销的作业
if(t==n){cout<<"无此作业，退出"<<endl;return;}
for( w=0;w<m;w++)
if(Vblock[w].flag==0)
{
Vblock[w].first=Cblock[t].first;
Vblock[w].length=Cblock[t].length;
Vblock[w].flag=1;ww=w;break;
}//Vblock[w]为回收的新空间
if(w==m){cout<<"无空表目登记，退出"<<endl;return;}
for( k=0;k<w;k++)
if(Vblock[w].first<Vblock[k].first)
{
for(kk=k;kk<w;kk++)
{ A[kk].first=Vblock[kk].first;
A[kk].length=Vblock[kk].length;
A[kk].flag=Vblock[kk].flag;
}
Vblock[k].first=Vblock[w].first;
Vblock[k].length=Vblock[w].length;
Vblock[k].flag=Vblock[w].flag;
for(kk=k+1;kk<=w;kk++)
{
Vblock[kk].first=A[kk-1].first;
Vblock[kk].length=A[kk-1].length;
Vblock[kk].flag=A[kk-1].flag;
}
break;
}
for(k=0;k<w;k++)
if(Vblock[k].first+Vblock[k].length==Vblock[k+1].first)
{
Vblock[k].length+=Vblock[k+1].length;
if(Vblock[k+2].flag==0) Vblock[k+1].flag=0;
else
{
for(j=k+2;j<=w;j++)
{
A[j].first=Vblock[j].first;
A[j].length=Vblock[j].length;
A[j].flag=Vblock[j].flag;
}
for(j=k+1;j<w;j++)
{ Vblock[j].first=A[j+1].first;
Vblock[j].length=A[j+1].length;
Vblock[j].flag=A[j+1].flag;
}
Vblock[w].first=0;
Vblock[w].length=0;
Vblock[w].flag=0;
w--;k--;
}
}
for( j=t+1;j<n;j++)
{
B[j].first=Cblock[j].first;
B[j].length=Cblock[j].length;
strcpy(B[j].name,Cblock[j].name);
}
for( j=t;j<n-1;j++)
{
Cblock[j].first=B[j+1].first;
Cblock[j].length=B[j+1].length;
strcpy(Cblock[j].name,B[j+1].name);
}
Cblock[n-1].first=0;
Cblock[n-1].length=0;
strcpy(Cblock[n-1].name,"0");
cout<<"作业"<<name<<"已回收"<<endl;
}
void main()
{
int i;
int fff;
Vblock[0].first=14;
Vblock[0].length=12;
Vblock[0].flag=1;
Vblock[1].first=32;
Vblock[1].length=96;
Vblock[1].flag=1;
for( i=2;i<m;i++)
{
Vblock[i].first=0;
Vblock[i].length=0;
Vblock[i].flag=0;
}
Cblock[0].first=5;
Cblock[0].length=5;
strcpy(Cblock[0].name,"J1");
Cblock[1].first=10;
Cblock[1].length=4;
strcpy(Cblock[1].name,"J3");
Cblock[2].first=26;
Cblock[2].length=6;
strcpy(Cblock[2].name,"J2");
for(i=3;i<n;i++)
{
Cblock[i].first=0;
Cblock[i].length=0;
strcpy(Cblock[i].name,"0");
}
print();
cout<<"若申请内存按1，释放内存按2,退出按0：";
cin>>fff;
for(int t=0;;t++)
{
switch(fff)
{
case 0: exit(1);break;
case 1:
request();print();break;
case 2: freeblock();print();break;
}
cout<<"若申请内存按1，释放内存按2,退出按0：";
cin>>fff;
}
}
5.实验结果
6．实验结论与总结
本次实验基本达到了实验目的。
通过本次实验我进一步了解了最佳适应模拟分配算法分配内存空间，本实验完成的比较简单，可以分配内存，释放内存，如果释放的内存和可分配的内存是连续的空间，则把它们连在一起，程序主要是实现几种不同的情况下应该怎样运算，程序实现并不算太难，几种情况分清是最重要的，同时我记忆不明白了实验原理，通过实验，真正的掌握着这种算法，以后做题时也会比较熟练，最后感谢老师耐心的指导，让我更加熟练的掌握了这种算法。
附录：流程图
最先适应分配算法流程图
主存回收算法